Power of Three Problem Solution with Recursion

🚀 50 Important Coding Questions – Question 50/50 🔹 Subsets (Power Set) | LeetCode A classic problem to master recursion + backtracking. 📌 Problem Statement Given an integer array, return all possible subsets (the power set). 💡 Approach Used (Backtracking / Recursion) I solved this using a recursive backtracking approach where: 👉 At every index, we have two choices Include the current element Exclude the current element 👉 Maintain a temporary list to build subsets 👉 When we reach the end of the array, store the current subset 🔍 How it works 👉 Traverse the array index by index 👉 For each element: First include it and move forward Then backtrack (remove it) and explore exclusion 👉 This forms a decision tree (include / exclude) ⏱ Time Complexity: O(2ⁿ) 📦 Space Complexity: O(n) (recursion stack) 📌 LeetCode Result ✔ Accepted ⚡ Runtime: 0 ms 🧠 Concepts Strengthened ✔ Backtracking fundamentals ✔ Recursion tree thinking ✔ Include–Exclude pattern ✔ State management (push & pop) 🏁 50/50 Questions Completed! 💯🔥 Consistency = Results 💪 From basics → advanced patterns 🚀 #DSA #LeetCode #Backtracking #Recursion #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

🚀 Day 13 of My Coding Journey Today I worked on an interesting problem: 527 Valid Word Abbreviation 💡 👉 The challenge was to check whether a given abbreviation correctly represents a word. It involved handling: Character matching ✅ Skipping characters using numbers 🔢 Edge cases like leading zeros ❌ 💻 Key Logic I Used: Two pointers (i for word, j for abbreviation) If characters match → move both pointers If digit found → build number and skip characters in word If invalid case → return false ✨ Code Snippet: class Solution { public: bool validWordAbbreviation(string word, string abbr) { int i=0, j=0; while(i<word.size() && j<abbr.size()) { if(abbr[j]=='0') return false; if(word[i]==abbr[j]) { i++; j++; } else if(isalpha(abbr[j])) return false; else { int num=0; while(j<abbr.size() && isdigit(abbr[j])) { num = (num*10) + (abbr[j]-'0'); j++; } i += num; } } return i==word.size() && j==abbr.size(); } }; 🧠 What I Learned: How to efficiently parse strings with mixed characters & numbers Importance of handling edge cases like "01" ❗ Two-pointer technique is 🔥 for string problems 📌 Consistency > Perfection See you tomorrow with Day 14! 💪 #100DaysOfCode #DSA #Cpp #CodingJourney #LeetCode #ProblemSolving

Check out my latest blog published blog on Medium about coding practices that made my project cleaner, more structured, and easier to manage. As a student working on my second-semester project, I started applying concepts like modular programming, virtual environments, logging, and secure configuration handling. Initially, they felt like extra effort. But over time, I realized how much they improve code quality and maintainability. In this blog, I’ve shared practical insights on: • Using virtual environments to avoid dependency conflicts • Managing dependencies with requirements.txt • Structuring projects using modular execution • Replacing print statements with proper logging • Keeping configs clean with .ini files • Securing sensitive data using AES encryption These small practices, when combined, make your codebase more professional and scalable. If you're building projects (especially as a beginner), adopting these early can save a lot of time and effort later. Would love to hear your thoughts and feedback! #Python #SoftwareDevelopment #CodingPractices #LearningInPublic #StudentsInTech #Programming #CleanCode https://lnkd.in/gW-QtcgV

Day 51 of My 90-Day Coding Challenge Today’s focus was on recursion, and honestly — it’s not as simple as it looks. I solved Letter Combinations of a Phone Number, which seems straightforward at first, but quickly tests how well you actually understand recursive thinking. The real challenge wasn’t writing code — it was thinking in terms of: • Breaking the problem into smaller subproblems • Building combinations step by step • Managing the recursive flow correctly Key learning: Recursion is not about memorizing patterns — it’s about visualizing the decision tree and trusting the process. One mistake I noticed: If you don’t clearly understand the base case and transitions, recursion becomes confusing very fast. What improved today: • Better clarity on how combinations are formed • Stronger grip on recursion structure (index + choices) • More confidence in handling backtracking-style problems Hard truth: Recursion feels difficult because the thinking is different — not because the problem is hard. And that’s exactly why it’s important to master it. #90DaysOfCode #DSA #Java #Recursion #Backtracking #LeetCode #ProblemSolving

Day 55 of 100 Days of LeetCode 💻 Today I solved Longest Consecutive Sequence — and honestly, this one taught me more about coding discipline than algorithms. At first, my approach was correct: Used HashSet for O(1) lookup Applied the “start of sequence” logic But I still got TLE. The reason? A tiny mistake: if(!set.contains(num-1)); That single ; made my condition useless and turned my O(n) solution into O(n²). 💡 Lesson learned: Don’t just think your logic is right → verify what your code actually does Small syntax mistakes can completely break optimal solutions Debugging is just as important as problem-solving Finally fixed it and got Accepted ✅ Slowly improving not just in DSA, but in writing cleaner and more careful code. #100DaysOfLeetCode #DSA #Java #CodingJourney #Learning

🚀 Day 10 of 100 Days LeetCode Challenge Problem: Find All Possible Stable Binary Arrays II Today’s problem is an extension of Day 9—but with optimized Dynamic Programming ⚡ 💡 Key Insight: Same constraints: Fixed number of 0s and 1s No more than limit consecutive identical elements 👉 Which means: We must carefully control streak length And efficiently count all valid combinations 🔍 Approach (Optimized DP): Use DP + Prefix Sum Optimization State includes: Count of 0s used Count of 1s used Ending with 0 or 1 💡 Optimization: Instead of recalculating ranges repeatedly, use prefix sums This reduces time complexity significantly 👉 Apply modulo (10⁹ + 7) for large answers 🔥 What I Learned Today: Same problem can have multiple levels of optimization Prefix sum is powerful in reducing DP transitions Moving from brute → DP → optimized DP is real growth 📈 📈 Challenge Progress: Day 10/100 ✅ Double digits achieved! LeetCode, Dynamic Programming, Prefix Sum, Optimization, Combinatorics, Binary Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #DynamicProgramming #PrefixSum #Optimization #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Ever wondered how to optimize your code with dynamic programming? Let's break it down! 🤔 Dynamic programming is a technique used to solve complex problems by breaking them down into simpler subproblems. By storing the results of subproblems, we can avoid redundant computations and improve the efficiency of our code. This is crucial for developers as it can significantly enhance the performance of algorithms, making them faster and more scalable. 👉 Here's a simple step-by-step breakdown: 1️⃣ Identify the problem and determine if it can be divided into subproblems. 2️⃣ Define a recursive function to solve each subproblem efficiently. 3️⃣ Store the results of subproblems in a data structure like an array or hashmap. 4️⃣ Write the base case to stop the recursion. 5️⃣ Implement the recursive function using memoization or tabulation. 🚨 Pro tip: Start with a brute-force solution first to understand the problem before optimizing with dynamic programming techniques. ❌ Common mistake to avoid: Forgetting to handle edge cases or not initializing the base cases correctly can lead to incorrect results. 🤔 What's your favorite dynamic programming problem to solve? Share below! ⬇️ 🌐 View my full portfolio and more dev resources at tharindunipun.lk 🚀 #DynamicProgramming #Algorithm #CodingTips #DeveloperCommunity #CodeOptimization #TechTalk #LearnToCode #ProblemSolving #DevLife #DataStructures #SoftwareEngineering