"Day 110 of DSA Challenge: Generating Subsets with Backtracking"

🔥 Day 107 of My DSA Challenge – Combination Sum II 🔷 Problem : 40. Combination Sum II 🔷 Goal : Find all unique combinations of numbers from a given list that sum up to a target. Each number can be used only once, and duplicate combinations are not allowed. 🔷 Key Insight : This is a backtracking + deduplication problem. The challenge is not just summing numbers—it’s ensuring uniqueness and exploring all valid combinations efficiently. 🔷 Approach : 1️⃣ Sort the candidates to handle duplicates easily. 2️⃣ Recursively pick each number and reduce the target. 3️⃣ If the target hits zero, record the combination. 4️⃣ Backtrack to explore other possibilities. 5️⃣ Skip duplicates to avoid repeating combinations. 🔷 Complexity : Time: O(2^N) — exploring all subsets Space: O(N) — recursion stack and temporary list Backtracking teaches precision, patience, and logical thinking—every branch you explore is a test of careful reasoning. #Day107 #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Backtracking #Recursion #CombinationSum #CodingChallenge #Algorithms #DataStructures #DeveloperJourney #Growth #Programming #SoftwareEngineering #CodeDaily #TechJourney #EngineerMindset #CodeLearning #CompetitiveProgramming #LogicBuilding #CareerInTech

DSA Practice – Day 52 🚀 Problem: Happy Number (LeetCode 202) 📌 Problem Statement: A number is called happy if repeatedly replacing it with the sum of the squares of its digits eventually leads to 1. Return true if it’s a happy number, otherwise false. 🧩 Brute Force Approach: Keep track of all numbers seen in a set to detect loops. If you reach 1, Happy Number If a number repeats, Not Happy Time Complexity: O(log n) Space Complexity: O(log n) ⚡ Optimal Approach (Floyd’s Cycle Detection): Use two pointers — slow and fast. Move slow by one step and fast by two steps (using sum of squares). If they meet, there’s a cycle (not happy). If you reach 1, it’s a happy number. Time Complexity: O(log n) Space Complexity: O(1) ✨ What I Learned: How to detect cycles in number transformations. Applying Floyd’s cycle detection beyond linked lists. Improved logical problem-solving for number-based questions. #LeetCode #Java #ProblemSolving #DSA #CodingJourney #PlacementPrep

💡 Day 104 of My DSA Challenge – Combinations 🔷 Problem : 77. Combinations 🔷 Goal : Generate all possible combinations of k numbers chosen from the range [1, n]. Example → Input: n = 4, k = 2 Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]] 🔷 Key Insight : This is a backtracking problem — where we explore all possible ways of picking elements while maintaining order and avoiding repetition. The core difference from permutations is that the order of elements doesn’t matter — [1,2] and [2,1] are the same combination. 🔷 Approach : 1️⃣ Start from the first number (idx = 1). 2️⃣ At each step, decide whether to include the current number in the combination or skip it. 3️⃣ Recursively build combinations until the list size reaches k. 4️⃣ Backtrack to explore other possibilities. 🔷 My Java Approach : Used recursion to explore all inclusion/exclusion choices. Added combinations when list size equals k. Backtracked after each recursive call to maintain correct state. 🔷 Complexity : Time → O(C(n, k)) Space → O(k) (for recursion and temporary list) This problem strengthens understanding of decision trees and combinatorial logic, which form the backbone of many recursive and dynamic programming patterns. Every problem adds a new layer to logical thinking — today, it was about choosing without caring about order, but caring deeply about structure. #Day104 #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Backtracking #Recursion #Combinations #CodingChallenge #Programming #SoftwareEngineering #Algorithms #DataStructures #TechJourney #EngineerMindset #DeveloperJourney #GrowthMindset #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

🗓 Day 1 / 100 – #100DaysOfLeetCode 📌 Problem 637: Average of Levels in Binary Tree Given the root of a binary tree, the task was to return the average value of the nodes at each level in an array. For example, Input: [3,9,20,null,null,15,7] Output: [3.00000, 14.50000, 11.00000] 🧠 My Approach: Used Breadth-First Search (BFS) traversal to process the tree level by level: Initialized a queue and pushed the root node. For each level, iterated through all nodes, accumulating their values. Calculated the average of that level and added it to the result list. Continued until all levels were processed. This approach effectively uses a queue to handle each level’s nodes in order. ⏱ Time Complexity: O(n) – every node is visited once 💾 Space Complexity: O(w) – where w is the maximum width of the tree 💡 Key Learning: This problem strengthened my understanding of level-order traversal using BFS. It showed how queues can efficiently help process hierarchical structures like trees — not just for traversal, but also for aggregating information level-wise 🌳 #100DaysOfLeetCode #LeetCodeChallenge #Java #ProblemSolving #BinaryTree #BFS #DataStructures #Algorithms #DSA #CodingJourney #CodeEveryday #SoftwareEngineering #LearningInPublic #DeveloperJourney #TechStudent #CodingCommunity #LogicBuilding #CareerGrowth #KeepLearning #Programmer #TechCareer

🔥 Day 111 of My DSA Challenge – Subsets II (Handling Duplicates) 🔷 Problem : 90. Subsets II 🔷 Goal : Generate all possible subsets of an array that may contain duplicates No duplicate subsets allowed 🔷 Key Insight : This is an extension of the classic Subsets / Power Set problem — but here the array can contain duplicates, so we must avoid repeating subsets. Core idea : At each element, you can : ✅ Include it ❌ Skip it But when skipping, you must skip all duplicates of that element at that step this ensures all generated subsets are unique. 🔷 Approach : 1️⃣ Sort the array to group duplicates 2️⃣ Use recursion + backtracking to try all possibilities 3️⃣ Skip duplicate values when they appear in the same decision branch Time Complexity: O(2ⁿ) Space Complexity: O(n) Subsets II builds the backtracking mindset further: When values repeat, skip duplicate branches — not decisions. This pattern is powerful for problems like : ✅ Combination Sum II ✅ Unique permutations ✅ Partitioning problems Little wins → Big breakthroughs Every problem improves logic and patience. On to the next one 👊🔥 #Day111 #100DaysOfCode #LeetCode #DSA #Java #Backtracking #Recursion #Subsets #PowerSet #CodingChallenge #Algorithms #ProblemSolving #DeveloperJourney

DSA Practice – Day 54 🚀 Problem: Maximum Product Subarray Problem Statement: Find the contiguous subarray within an array (containing at least one number) which has the largest product. ⚡ Brute Force Approach: Generate all possible subarrays. Calculate the product of each subarray. Keep track of the maximum product found. Time Complexity: O(n²) Space Complexity: O(1) ⚡ Optimal Approach (Prefix–Suffix Product): Maintain two running products — prefix (left to right) and suffix (right to left). Reset the product to 1 whenever it becomes 0. Keep updating the maximum product found so far. Time Complexity: O(n) Space Complexity: O(1) ✨ What I Learned: Prefix–suffix logic can simplify problems that seem complex initially. Resetting counters or products helps handle zeros effectively. Great way to practice array traversal from both ends! #LeetCode #Java #DSA #ProblemSolving #CodingJourney #PlacementPrep

🎯 Day 12 – Check if a String is Palindrome Today’s DSA challenge focuses on verifying whether a given string reads the same backward and forward — a fundamental problem that strengthens your understanding of string manipulation and logical thinking. 💡 Key Learning: Small problems often reveal big insights — palindrome checking teaches precision, clean iteration, and boundary control. 🧠 Concepts Used: Strings Two-pointer technique Character comparison ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(1) 📘 Each problem reinforces how small logic improvements can lead to efficient, readable code. #Day12 #DSA #Java #Strings #KeepLearning #IntelliJ

🔥 Day 108 of My DSA Challenge – Merge Sorted Array 🔷 Problem : 88. Merge Sorted Array 🔷 Goal : Merge two sorted arrays into one sorted array in-place inside nums1. The tricky part? nums1 already has extra space at the end — and we need to fill it without using extra arrays. 🔷 Key Insight : Use the two-pointer technique starting from the end — this avoids overwriting values in nums1. Pointer p1 → end of valid elements in nums1 Pointer p2 → end of nums2 Pointer idx → last index in final merged array Place the largest element first by comparing from the end. 🔷 Approach : 1️⃣ Start from the last elements of both arrays 2️⃣ Compare and place the greater one at the end 3️⃣ Move pointers backwards 4️⃣ If nums2 still has elements, copy them This gives us O(m + n) time and O(1) extra space ✅ Sometimes the most elegant solutions are not about building new structures but smartly reusing what you already have. Two-pointer technique continues to be a powerful tool in array problems 💪 #Day108 #100DaysOfCode #LeetCode #DSA #Java #TwoPointers #Arrays #CodingChallenge #Algorithm #InPlaceAlgorithms #ProblemSolving #Programming #SoftwareEngineering #TechJourney #DeveloperJourney #CodeEveryday #LearnDSA #GrowthMindset #EngineerMindset #LogicBuilding

💡 Day 98 of My DSA Challenge – Longest Subsequence With Limited Sum 🔷 Problem: 2389. Longest Subsequence With Limited Sum 🔷 Goal: For each query, find the maximum number of elements from nums that can form a subsequence with a sum ≤ query value. 🔷 Key Insight: To maximize the subsequence size, we should always pick smaller elements first — this is a greedy choice. Hence, sorting the array ensures we can accumulate the smallest elements until the sum exceeds the query limit. Approach outline: 1️⃣ Sort the array nums. 2️⃣ For each query, add elements one by one until the sum crosses the limit. 3️⃣ Return the count of elements that fit within the limit. This logic can also be optimized further using prefix sums + binary search, but the greedy approach works perfectly within given constraints. 🔷 My Java Approach: Sort the array. Use a helper function to count how many elements fit under the query sum. Store each result in the answer array. 🔷 Complexity: Time → O(n log n + n × m) Space → O(1) Sometimes, simplicity wins. This problem reinforces the power of greedy thinking — starting small, building up gradually, and knowing when to stop. Recognizing such patterns is key to writing clean and intuitive code. 🚀 #100DaysOfCode #Day98 #LeetCode #DSA #Java #ProblemSolving #GreedyAlgorithm #CodingChallenge #Programming #LearnToCode #CodingLife #SoftwareEngineering #Algorithms #DataStructures #TechJourney #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #CodeNewbie #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

🚀 Day 17 of #50DaysOfLeetCodeChallenge 🚀 🧩 Problem: 88. Merge Sorted Array Today’s problem was all about merging two sorted arrays into one — maintaining non-decreasing order without using extra space! This problem reinforced my understanding of in-place array manipulation and sorting fundamentals. 💡Key Learning: Two-pointer logic or direct insertion can simplify merging. Efficient use of existing array space (nums1) avoids extra memory usage. Sorting the final combined array ensures non-decreasing order. ✅ Solution Highlights: Appended elements of nums2 to the end of nums1. Used Arrays.sort() to maintain sorted order. Time Complexity: O((m + n) log(m + n)) Runtime: 1 ms (Beats 27.22%) ⚡ 🎯 Status: Accepted ✅ — All test cases passed! This problem was a neat reminder of how simple array operations can teach powerful lessons about space optimization and clean algorithmic design. Grateful to Shishir chaurasiya and PrepInsta for their continuous guidance and motivation throughout this challenge! 🙌 #leetcode #coding #java #problemSolving #learning #prepinsta #DSA #50DaysOfLeetCodeChallenge