Solved LeetCode #17: Letter Combinations of a Phone Number with Recursion and Backtracking

🧠 Day 44 / 100 – Product of Array Except Self (LeetCode #238) Today’s challenge was all about computing an array where each element is the product of all numbers except itself — without using division. This one teaches prefix and suffix logic beautifully. The trick is to build two running products: One from the left (prefix) One from the right (suffix) Then combine both to get the final result. No division needed, no nested loops — just clean, efficient logic. 🔍 Key Learnings Use prefix and suffix multiplications for O(n) time complexity. Avoid division to handle zero cases efficiently. Think about how to reuse partial results rather than recomputing them. 💭 Thought of the Day Efficiency comes from rethinking the obvious. Instead of brute-forcing every combination, using prefix and suffix logic shows how planning ahead can simplify everything. Each day, I’m learning to design solutions, not just write them. 🔗 Problem Link: https://lnkd.in/gbGfa4dd #100DaysOfCode #Day44 #LeetCode #Python #Arrays #PrefixSum #ProblemSolving #Algorithms #DataStructures #EfficientCoding #CodeEveryday #LearningJourney #TechGrowth #CleanCode

🧠 Day 13 — Thinking in Ranges, Not Just Numbers Today’s LeetCode problem was “Maximum Frequency of an Element After Performing Operations I.” At first, it felt straightforward — perform up to numOperations changes on elements within a range of [-k, k] to maximize frequency. But once I got into it, I realized the real challenge wasn’t the operations — it was understanding how intervals overlap and interact. Here’s the logic I built around it: 🔹 Each number can shift within [num - k, num + k], forming a range of possible values. 🔹 The goal is to find how many such ranges overlap at any point — that overlap represents the maximum achievable frequency. 🔹 I used sorted events and a sweep line approach to track how many intervals are active at any moment. 🔹 The maximum overlap gives the answer — the highest number of elements that can become equal after allowed operations. This problem wasn’t just about code; it was about thinking visually — seeing numbers as segments on a line rather than static values. That shift in perspective changed how I approached it. Thanks to Shishir chaurasiya sir and PrepInsta team One more day, one more layer of understanding peeled back. #Day13 #LeetCode #ProblemSolving #100DaysOfCode #Python #Algorithms #DataStructures #KeepBuilding #DevMindset

Ever spent hours tweaking your code, hoping for lightning speed only to hit a wall? Last month, I was deep into a data pipeline, flipping between multithreading and multiprocessing, trying to squeeze out every ounce of performance. Here’s what finally clicked : If your code is waiting for files, networks, or APIs → Go multithreading If your code is crunching numbers nonstop → Go multiprocessing That simple switch changed everything. Suddenly, my script ran smoother AND faster. Lesson: “Threads for waiting, processes for working.” Easy to remember, game changing when applied. 👩💻 Ever faced this dilemma? Share your horror stories (or speed hacks) in the comments! Let’s help each other write better, faster code. #protip #Python #coding #learningbydoing #datapipelines

🚀 Day 26 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about string precision and pattern matching: 🔗 Implement strStr() (LeetCode) 📌 Challenge: Given two strings haystack and needle, return the index of the first occurrence of needle in haystack, or -1 if it doesn’t exist. 🔍 Approach: → Skipped the built-in .find() to implement it manually → Iterated through haystack only up to len(haystack) - len(needle) → Compared slices haystack[i:i+len(needle)] with needle → Returned the index on match, -1 otherwise 💡 What made it click: → Realized that checking every possible starting index is enough — no need to build substrings manually → Adjusting the loop range to avoid out-of-bound errors was the key → Removing redundant checks like if needle not in haystack made the code cleaner and faster 📚 What I learned: ✅ Substring search is a great intro to sliding window logic ✅ Clean loop bounds = fewer bugs ✅ Sometimes the simplest approach is the most elegant ✅ Writing your own version of built-ins deepens your understanding of how they work under the hood Have you implemented your own strStr() before? Did you go brute-force or try KMP? Let’s compare strategies 💬🔍 #Day26 #LeetCode #StringMatching #CodingChallenge #Python #ProblemSolving #CleanCode #CodeEveryDay #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #geeksforgeeks #100DaysOfCode

🧠 Day 38 / 100 – Recursion: Factorial of a Number (LeetCode-#509) Today’s challenge was all about recursion — one of the most elegant concepts in programming. I revisited the Factorial problem, which beautifully demonstrates how a big problem can be broken into smaller subproblems. The idea is simple: 👉 The factorial of n is n * factorial(n-1) until n becomes 1. But the real challenge lies in understanding the flow of recursive calls and how the call stack unwinds to give the final result. This problem reminded me that recursion isn’t just about repeating a function — it’s about trusting the process and thinking in terms of smaller steps to solve complex problems. 🔍 Key Learnings Every recursive function must have a base case to prevent infinite loops. The call stack stores each recursive call until it’s resolved. Recursion is a natural fit for problems that can be divided into smaller, similar subproblems. 💭 Thought of the Day Recursion teaches patience and structure. Sometimes, you need to trust that solving the smaller version of a problem will help you conquer the big one — both in code and in life 💫. 🔗 Reference Problem:https://lnkd.in/g3yNGDbJ #100DaysOfCode #Day38 #LeetCode #Python #Recursion #Factorial #ProblemSolving #CodingChallenge #Algorithms #ProgrammingMindset #DataStructures #CleanCode #LearnByDoing #TechGrowth #PythonProgramming

💯 Day 42 / 100 – 100 Days of #LeetCode Challenge 🔁 Problem: 744. Find Smallest Letter Greater Than Target Goal: Given a sorted list of letters and a target letter, find the smallest letter that is greater than the target. The list wraps around, meaning if no letter is greater, return the first letter in the list. Approach: ✅ Sort the list to ensure it’s in order (though usually given sorted). ✅ Iterate through the letters: If a letter is greater than the target, return it immediately. ✅ If no such letter exists, return the first letter (wrap-around case). Complexity: ⏱ Time: O(n) – Linear scan through the letters. 🗂 Space: O(1) – Constant extra space. 💡 Key Takeaways: Simple iteration logic can solve problems efficiently without extra data structures. Watch out for wrap-around conditions in sorted arrays. This problem is a good intro to binary search optimization ideas! #100DaysOfLeetCode #Day42 #Python #DSA #Stack #ProblemSolving #CodingChallenge #LeetCode #LearningEveryday

Day 39 / 100 – Combination Sum (LeetCode #39) Today’s challenge was Combination Sum, a classic problem that teaches how to explore all possible combinations that add up to a target. The key idea here is recursion with backtracking — trying different paths, and “undoing” choices when they don’t lead to a solution. At first, it felt complex to keep track of combinations without duplicates, but recursion made it elegant once I understood how to structure the calls properly. It’s a great example of how backtracking mirrors human problem-solving: try, fail, and refine until success. 🔍 Key Learnings Recursion helps break complex problems into smaller, reusable patterns. Backtracking avoids unnecessary computation by pruning invalid paths early. Always remember to copy the current combination when adding it to results — lists are mutable! 💭 Thought of the Day Sometimes the most powerful solutions come from simplicity — recursion mirrors the way we naturally think through problems step by step. Today’s problem reminded me that patience and clarity often lead to clean, beautiful solutions ✨ 🔗 Problem Link: https://lnkd.in/gxtE573Z 🏷️ #100DaysOfCode #Day39 #LeetCode #Python #Recursion #Backtracking #ProblemSolving #Algorithms #DataStructures #CodingChallenge #LearnToCode #CleanCode #MindsetMatters #CodeEveryday #TechJourney

🚀 Day 32 of #100DaysOfCode — LeetCode + HackerRank Edition! Today’s challenge was all about frequency mapping and subarray logic — solving the Picking Numbers problem from HackerRank. 🔗 Problem: pickingNumbers(a) (HackerRank) 📌 Challenge: Given an array of integers, find the length of the longest subarray where the absolute difference between any two elements is ≤ 1. 🔍 Approach: → Used Python’s Counter to map frequencies of each number → For each number num, calculated freq[num] + freq[num + 1] → Tracked the maximum such sum to find the longest valid subarray → Avoided brute-force by leveraging frequency patterns instead of scanning all subarrays 💡 What made it click: → Realized that valid subarrays must contain only num and num + 1 → Frequency mapping reveals hidden structure in the data → Clean logic with max() and get() made the solution elegant and readable 📚 What I learned: ✅ Frequency-based thinking can simplify subarray problems ✅ Counter is a powerful tool for pattern detection ✅ Avoiding brute-force leads to scalable, efficient solutions ✅ Sharing dry runs and visual walkthroughs helps others grasp the intuition faster Have you tackled Picking Numbers before? Did you go with sorting, brute-force, or frequency mapping like I did? Let’s swap strategies 💬 #Day31 #HackerRank #SubarrayLogic #FrequencyMapping #Python #ProblemSolving #CleanCode #CodeEveryDay #LearnToCode #CodeNewbie #SoftwareEngineering #TechJourney #100DaysOfCode

🚀 Day 51 of #100DaysOfCode — LeetCode + HackerRank Edition Today’s challenge: Spiral Matrix — traverse a matrix in spiral order and return the elements. 🌀🧩 Problem (brief): Given an m x n matrix, return all elements in spiral order (clockwise starting from top-left). 📌 My approach →Use four boundaries: top, bottom, left, right. →Walk: left→right along top, top→bottom along right, right→left along bottom, bottom→top along left. →After each traversal, move the corresponding boundary inward. →Repeat while top <= bottom and left <= right. →Handle edge cases: single row, single column, or empty matrix. 💡 What I learned today: ✅Boundary-driven traversal is a neat pattern — useful for many matrix problems. ✅Always check the top<=bottom and left<=right conditions before traversing opposite sides to avoid duplicates. ✅Dry runs are everything — they reveal off-by-one bugs faster than tests. Let’s share patterns — how do you solve Spiral Matrix? Do you prefer boundary pointers, or recursion (peel the outer layer)? Drop your implementation or edge cases — I’ll compare notes! 👇 #Day51 #100DaysOfCode #LeetCode #Python #DSA #SpiralMatrix #ProblemSolving #CodeNewbie #LearnInPublic