Combination Sum III Backtracking Solution

#200DaysOfCode – Day 106 Backtracking & Recursion | Combination Sum II Problem: Combination Sum II Task: Given an array of candidate numbers and a target, find all unique combinations where the numbers sum up to the target. Each number can be used only once, and duplicate combinations are not allowed. Example: Input: candidates = [10,1,2,7,6,1,5], target = 8 Output: [1,1,6], [1,2,5], [1,7], [2,6] My Approach: Sorted the array to handle duplicates efficiently. Used backtracking to explore all valid combinations. Skipped duplicate elements to avoid repeated combinations. Pruned recursion when the current value exceeded the target. Time Complexity: Exponential (Backtracking) Space Complexity: O(N) due to recursion stack Backtracking becomes much cleaner and more efficient when combined with sorting and smart pruning. Understanding when to skip elements is just as important as choosing them. #takeUforward #100DaysOfCode #Java #ProblemSolving #LeetCode #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie #Consistency

Day 45/100 – #100DaysOfCode 🚀 Solved Remove All Adjacent Duplicates in String (LeetCode) using a Stack. Approach : -> Traverse the string character by character. -> If the stack is not empty and the top character is the same as the current one → pop it (remove the duplicate). -> Otherwise, push the current character onto the stack. -> After processing the full string, the stack contains the final characters (in reverse order). -> Build the result by popping from the stack and reversing it. This approach works in O(n) time and avoids unnecessary comparisons. #DSA #Stacks #LeetCode #ProblemSolving #Java #LearningEveryday #100DaysOfCode

🚀 Day 13 of #100DaysOfCode – Binary Search in Action-Today I solved LeetCode 1283: Find the Smallest Divisor Given a Threshold and it was a great example of how Binary Search can be applied beyond sorted arrays. 👉 This monotonic behavior makes the problem perfect for Binary Search. ⏱️ Complexity Time: O(n log max(nums)) Space: O(1) 📌 Key Takeaway Binary Search isn’t just for sorted arrays — 👉 If the answer space is monotonic, Binary Search can optimize it efficiently. #100DaysOfCode #Day12 #BinarySearch #LeetCode #Java #DSA #ProblemSolving #CodingJourney 💻✨

LeetCode Practice - 747. Largest Number At Least Twice of Others ✅ Approach (Simple Logic) 1. Read the size of the array. 2. Read array elements dynamically. 3. Find: 📌the largest number 📌its index 4. Check whether the largest number is at least twice every other number. 5. If yes → return its index Else → return -1 #LeetCode #Java #CodingPractice #ProblemSolving #DSA #Array #DeveloperJourney #TechLearning

#200DaysOfCode – Day 105 Backtracking & Recursion 🔹 Problem:- Combination Sum (LeetCode 39) Task: Given an array of distinct integers and a target value, find all unique combinations where the chosen numbers sum to the target. Each number can be used multiple times. Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3], [7]] My Approach: Used Backtracking to explore all possible combinations. At each step, decided to pick or skip the current element. Allowed reuse of elements by staying on the same index. Backtracked once the target became negative or a valid combination was found. Time Complexity: Exponential (based on number of combinations) Space Complexity: O(Target) (recursion stack + current path) Key Takeaway: Backtracking is all about choices and reversals. Once the pick / not-pick pattern becomes clear, complex problems start feeling much simpler. #takeUforward #200DaysOfCode #Java #Backtracking #Recursion #ProblemSolving #LeetCode #DSA #CodeNewbie #LearningInPublic #Consistency

LeetCode Practice - 541. Reverse String ll 💡 Key Idea : ✔Move through the string in blocks of size 2k ✔For each block: Reverse the first k characters Leave the remaining characters as they are ✔Handle edge cases automatically: If remaining characters < k → reverse all If remaining characters between k and 2k → reverse only the first k #LeetCode #Java #StringHandling #CodingPractice #ProblemSolving #DSA #DeveloperJourney #TechLearning

Problem 2: Symmetric (Mirror) Tree Level: Easy–Medium Platform: LeetCode 101 A tree is symmetric if left subtree is a mirror of right subtree. 🔹 Mirror Rules Two nodes a and b must satisfy: Copy code a.val == b.val a.left ↔ b.right a.right ↔ b.left 🔹 Java Code class Solution { public boolean isSymmetric(TreeNode root) { return isMirror(root.left, root.right); } private boolean isMirror(TreeNode a, TreeNode b) { if (a == null && b == null) return true; if (a == null || b == null) return false; if (a.val != b.val) return false; return isMirror(a.left, b.right) && isMirror(a.right, b.left); } } 🔹 Explanation Compare trees in cross direction left.left with right.right left.right with right.left If every pair matches → tree is symmetric Time: O(n) Space: O(h) #DSA #DataStructuresAndAlgorithms #Coding #Programmer #LeetCode #CodeEveryday #JavaDSA #CodingPractice #ProblemSolving #CP #CompetitiveProgramming #DailyCoding #TechJourney #CodingCommunity #DeveloperLife #100DaysOfCode #CodeWithMe #LearnToCode #GeekForGeeks #CodingMotivation

#200DaysOfCode – Day 103 Generate Parentheses Problem :- Generate Parentheses Task :- Given n pairs of parentheses, generate all combinations of well-formed parentheses. Example: Input: n = 3 Output: ["((()))","(()())","(())()","()(())","()()()"] My Approach: Used Backtracking to build the string step by step. Tracked the count of open and close brackets. Added '(' only when open < n. Added ')' only when close < open. Stored the result when the string length reached 2 * n. Time Complexity: Exponential (Catalan-based) Space Complexity: O(n) (recursion stack) Key Takeaway: Instead of generating all possibilities and checking validity later, applying constraints during recursion leads to clean, efficient, and elegant solutions. #takeUforward #200DaysOfCode #Java #LeetCode #ProblemSolving #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie #CleanCode

Solved this problem by finding the largest and second largest elements in the array using a single loop. Once identified, applied the formula: (max − 1) × (secondMax − 1) This approach runs in O(n) time and uses O(1) extra space, making it both efficient and interview-friendly. A good reminder that many problems can be optimized by tracking values smartly instead of sorting. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #InterviewPrep