Combination Sum Problem Backtracking Challenge

🚀 100 Days of Code Day-25 LeetCode Problem Solved: Reverse Nodes in k-Group I recently worked on a Linked List problem that focuses on reversing nodes in groups of size k while preserving the remaining structure if the group size is less than k. 🔹 Strengthened my understanding of pointer manipulation 🔹 Improved problem decomposition skills 🔹 Practiced recursive thinking for efficient implementation 💡 Key takeaway: Breaking complex problems into smaller, manageable parts significantly simplifies the solution approach. Continuing to build consistency in problem-solving and deepen my understanding of Data Structures & Algorithms. #LeetCode #DataStructures #Algorithms #Java #ProblemSolving #SoftwareDevelopment

🚀 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

## 🧩 Solved LeetCode 9 – Palindrome Number Today I revisited a fundamental integer manipulation problem: determining if a number reads the same forward and backward without converting it to a string. 🔍 **Problem Insight:** While string conversion makes this trivial, the real challenge is solving it mathematically. The goal is to reverse the integer (or half of it) and compare it to the original while being mindful of potential integer overflow. 💡 **Key Learnings:**  * **Negative Numbers:** Any negative number is immediately invalid (e.g., -121 becomes 121-).  * **Mathematical Reversal:** Using modulo % 10 and integer division / 10 allows us to "pop" and "push" digits.  * **Optimization:** We only need to reverse **half** of the number. Once the original number becomes less than or equal to the reversed half, we've reached the middle.  * **Edge Case Savvy:** Numbers ending in 0 (except 0 itself) cannot be palindromes. ⚙️ **Approach Used:**  1. Eliminate negative numbers and numbers ending in 0.  2. Build the reversed half of the number by iteratively taking the last digit.  3. Stop when the reversed part is \ge the remaining part.  4. Check for equality (handling odd-lengthed numbers by dividing the reversed part by 10). 📊 **Complexity:**  * **Time:** O(\log_{10}(n)) — we divide the input by 10 in every iteration.  * **Space:** O(1) — constant space used regardless of input size. 🔥 **Takeaway:** This problem is a perfect example of why we shouldn't always reach for the easiest data type conversion. Thinking in terms of pure logic and math often leads to a more memory-efficient and elegant solution. #LeetCode #Algorithms #Math #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

🚀Day 29 Solved LeetCode Problem #129 – Sum Root to Leaf Numbers Today I worked on a Binary Tree problem that focuses on DFS traversal and number formation from root-to-leaf paths. 🌳 🔹 Problem: Given a binary tree where each node contains digits (0–9), every root-to-leaf path forms a number. The goal is to calculate the total sum of all these numbers. 🔹 Example: Tree: [1,2,3] Paths: 1 → 2 = 12 1 → 3 = 13 Total Sum = 12 + 13 = 25 🔹 Approach: ✔ Use Depth First Search (DFS) ✔ Build the number while traversing the tree ✔ Multiply previous value by 10 and add the current digit ✔ When reaching a leaf node, add the number to the total sum ⏱ Time Complexity: O(n) 📦 Space Complexity: O(h) 💡 Key Learning: This problem helped strengthen my understanding of Binary Tree traversal and how recursive DFS can be used to carry state across nodes. Excited to keep improving my problem-solving skills! 💻🔥 #leetcode #datastructures #algorithms #java #binarytree #coding #softwaredeveloper #codingjourney

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 49 of #100DaysOfCode ✅ Solved: Find the Difference 🔍 What I did: Used a clever XOR bit manipulation technique to identify the extra character between two strings efficiently. 💡 Key Learning: XOR cancels out identical characters Helps find unique elements in linear time Clean and optimal approach without extra space ⚡ Time Complexity: O(n) 📦 Space Complexity: O(1) 🎯 Takeaway: Sometimes the best solutions are not obvious — learning small tricks like XOR can make a big difference in problem solving. #Java #LeetCode #ProblemSolving #CodingJourney #100DaysChallenge #DataStructures #Algorithms

🚀 Just solved the Contains Duplicate problem with a fresh perspective! Instead of going with the traditional sorting + two pointer approach, I used the property of Set (uniqueness) to achieve an O(n) time complexity solution. 💡 Approach: - Traverse the array once - Use a HashSet to track elements - If an element already exists → duplicate found ⚡ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔁 On the other hand, the sorting + two pointer approach gives: - Time: O(n log n) - Space: O(1) 👉 So it’s a classic trade-off: - Optimize time → use Set - Optimize space → use Sorting+two pointer Really enjoyed breaking down this problem and comparing approaches — small problems like this build strong intuition for bigger ones 💪 #DataStructures #Algorithms #LeetCode #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 81 – DSA Journey | Binary Tree Inorder Traversal Continuing my daily DSA practice, today I explored tree traversal and how stacks can simulate recursion. 📌 Problem Practiced: Binary Tree Inorder Traversal (LeetCode 94) 🔍 Problem Idea: Traverse a binary tree in inorder sequence — Left → Root → Right — and return the values of nodes. 💡 Key Insight: Instead of recursion, we can use a stack to iteratively traverse the tree by going as left as possible, then processing nodes and moving right. 📌 Approach Used: • Use a stack to simulate recursion • Start from root and go to the leftmost node • Push nodes while moving left • Pop from stack, process the node • Move to the right subtree and repeat 📌 Concepts Strengthened: • Tree traversal (Inorder) • Stack usage in trees • Iterative vs recursive approaches • Understanding tree structure ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Recursion can always be converted into iteration using stacks — understanding this gives more control over traversal logic. On to Day 82! 🚀 #Day81 #DSAJourney #LeetCode #BinaryTree #Stack #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 19/100 — #100DaysOfLeetCode Back to mastering one of the most powerful patterns in DSA — Sliding Window 💻🔥 ✅ Problem Solved: 🔹 LeetCode 1358 — Number of Substrings Containing All Three Characters 💡 Concept Used: Sliding Window + Frequency Tracking 🧠 Key Learning: The goal was to count all substrings containing 'a', 'b', and 'c'. Instead of checking every possible substring, I learned how: Expand the window until all required characters are present. Once valid, every further extension also forms valid substrings. Count substrings efficiently while shrinking the window. This converts a brute-force O(n²) approach into an optimized O(n) solution. ⚡ Big Insight: Sliding Window isn’t just about finding length — it can also be used for counting valid substrings efficiently. Consistency is slowly turning patterns into instincts 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

Day 19 of my #30DayCodeChallenge: Mastering Backtracking! The Problem: Combination Sum. Finding all unique combinations of candidates that sum up to a specific target, where each number can be used an unlimited number of times. The Logic: This problem is a perfect example of how Recursion and Backtracking allow us to explore multiple paths while pruning the ones that don't lead to a solution. 1. State-Space Exploration: I used a recursive approach to explore every possible combination. By passing the current index forward, we ensure we don't pick the same set of numbers in a different order, keeping the results unique. 2. The "Unlimited" Choice: Unlike some problems where you move to the next element immediately, here we have the option to stay on the same element to achieve the "unlimited times" constraint-as long as the remaining target allows it. 3. Backtracking & Pru.. If the current sum exceeds the target. we ston exploring that branch (Backtrack). This keeps the algorithm efficient even as the depth of the recursion grows. One more step toward algorithmic mastery. Onward to Day 20! #Java #Algorithms #DataStructures #Backtracking #ProblemSolving #150DaysOfCode #SoftwareEngineering #LeetCode