Generate Parentheses Combinations with Backtracking DSA Challenge

🔥 DSA Challenge – Day 125/360 🚀 📌 Topic: Recursion 🧩 Problem: Combination Sum Problem Statement: Given an array of distinct integers and a target, return all unique combinations where numbers sum up to the target. Same element can be used multiple times. 🔍 Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] 💡 Approach: Backtracking 1️⃣ Step 1 – Start from index 0 and try picking each element 2️⃣ Step 2 – If element ≤ target, include it and reduce target 3️⃣ Step 3 – Backtrack (remove element) and move to next index ✔ Use recursion to explore all possibilities ✔ Reuse same element (stay on same index) ✔ Stop when target becomes 0 (valid answer) ✔ Skip when index reaches end ⏱ Complexity: Time: O(2^n * k) (k = avg length of combination) Space: O(k * x) (x = number of combinations) 📚 Key Learning: Backtracking is all about making choices, exploring, and undoing them efficiently. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking 🚀

🔥 DSA Challenge – Day 127/360 🚀 📌 Topic: Backtracking 🧩 Problem: Subsets II Problem Statement: Given an integer array that may contain duplicates, return all possible subsets such that the solution set does not contain duplicate subsets. 🔍 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] 💡 Approach: Backtracking + Sorting 1️⃣ Step 1 – Sort the array to group duplicate elements together 2️⃣ Step 2 – Use recursion to generate all subsets 3️⃣ Step 3 – Skip duplicate elements using condition (i != ind && nums[i] == nums[i-1]) ⏱ Complexity: Time: O(2^n) Space: O(n) (recursion stack + subset storage) 📚 Key Learning: Sorting + smart skipping of duplicates helps avoid repeated subsets in backtracking problems. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #360DaysOfCode #LeetCode #Backtracking

😎 Day 39 of Solving dsa -->longest consecutive sequence. 🚀 Approach First, add all elements of the input array nums into a hash set for efficient O(1) lookups. Initialize a variable longest_streak to 0. Iterate through the array nums again. For each number num: Check if num - 1 exists in the hash set. If it does, num is part of a longer sequence that will be processed later, so we skip it. If num - 1 does not exist in the hash set, num is the start of a consecutive sequence. Start a nested loop from num, incrementing by one, and check if each subsequent number exists in the set. Count the length of this sequence. Update longest_streak with the maximum length found so far. Return longest_streak. 📈 Complexity Time complexity: O(n) — Although there is a nested loop, each element in the hash set is visited at most twice: once during insertion and once during a streak check. Space complexity: O(n) — We store all n elements in the hash set. #programming #solving #java #dsa #100 days challenge #logic #leetcode #striversheeet #tuf #daily challenge

🚀 Starting a New Topic: Recursion 🔥 DSA Challenge – Day 118/360 📌 Topic: String 🧩 Problem: String to Integer (atoi) Problem Statement: Convert a string into a 32-bit signed integer while handling spaces, sign, non-digit characters, and overflow. 🔍 Example: Input: " -42" Output: -42 💡 Approach: Recursion + Parsing 1️⃣ Step 1 – Skip leading spaces and detect sign (+ / -) 2️⃣ Step 2 – Recursively process each digit and build the number 3️⃣ Step 3 – Check overflow at every step and return result ⏱ Complexity: Time: O(n) Space: O(n) (recursive stack) 📚 Key Learning: Always handle overflow during computation, not after building the full number. Recursion simplifies problems by breaking them into smaller subproblems. 💭 New Topic Journey Begins: Excited to dive deep into Recursion and master it step by step! 💪 #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #118DaysOfCode #LeetCode #Recursion

Day 11/90 DSA Journey Today I implemented an efficient solution for the classic DSA problem “Subarray Sum Equals K” using Prefix Sum + HashMap. -> Approach: Maintain a running prefix sum while traversing the array. Use a HashMap to store the frequency of prefix sums. At each index, check if (currentSum - k) exists in the map. If it exists, it means there is a subarray ending at the current index with sum = k. -> Key Insight: If sum[j] - sum[i] = k, then the subarray (i+1 to j) has sum k. -> Code Highlights: Initialize map.put(0,1) to handle edge cases. Continuously update frequency of prefix sums. Efficient lookup using HashMap. -> Time Complexity: -> O(n) — We traverse the array only once. -> Space Complexity: -> O(n) — In the worst case, we store all prefix sums in the HashMap. -> Why this is powerful? This approach avoids nested loops (O(n²)) and optimizes the solution using hashing. #DSA #Java #LeetCode #Coding #Hashing #PrefixSum #ProblemSolving

🔥 DSA Challenge – Day 128/360 🚀 📌 Topic: Recursion 🧩 Problem: Letter Combinations of a Phone Number 💡 Problem Statement: Given a string of digits (2–9), return all possible letter combinations that the number could represent based on the classic phone keypad mapping. 🔍 Example: Input: "23" Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"] 💡 Approach: Backtracking (Recursion) We treat this like a decision tree: Each digit maps to multiple characters For every digit, we try all possible letters Build combinations step-by-step using recursion 👉 Key Idea: Choose → Explore → Backtrack Use StringBuilder for efficient string manipulation ⚙️ Steps: Create a mapping for digits → letters Start recursion from index 0 For each digit: Loop through its mapped letters Add letter to current string Move to next digit Backtrack (remove last character) 🚀 Code Highlights: ✔️ Base case: when index reaches end → add combination ✔️ Efficient backtracking using StringBuilder ✔️ Avoids extra space by modifying same string ⏱️ Time Complexity: O(4^N) 📦 Space Complexity: O(N) (recursion stack) Master this → You master recursion 🔥 #DSA #Java #Backtracking #CodingInterview #LeetCode #128DaysOfCode #Programming #Tech #ProblemSolving

🔥 DSA Challenge – Day 131/360 🚀 📌 Topic: Backtracking / Recursion 🧩 Problem: N-Queens Problem Statement: Place N queens on an N×N chessboard such that no two queens attack each other. 🔍 Example: Input: n = 4 Output: [[".Q..","...Q","Q...","..Q."], ["..Q.","Q...","...Q",".Q.."]] 💡 Approach: Optimized Backtracking (Hashing) 1️⃣ Step 1 – Try placing a queen column by column 2️⃣ Step 2 – Use arrays to check if row & diagonals are safe in O(1) 3️⃣ Step 3 – Place queen → recurse → backtrack if needed ⏱ Complexity: Time: O(N!) Space: O(N) + recursion stack 📚 Key Learning: Using hashing for rows & diagonals avoids repeated checks and makes backtracking much faster ⚡ #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #131DaysOfCode #LeetCode

🔥 DSA Challenge – Day 135/360 🚀 📌 Topic: Bit Manipulation 🧩 Problem: Check if a Number is Power of 2 Problem Statement: Given an integer n, determine whether it is a power of 2 or not. 🔍 Example: Input: n = 4 Output: true Input: n = 6 Output: false 💡 Approach: Optimized (Bit Manipulation) 1️⃣ Step 1 – If n <= 0, return false (powers of 2 are always positive) 2️⃣ Step 2 – Use bit trick: n & (n - 1) removes the lowest set bit 3️⃣ Step 3 – If result becomes 0, then only one set bit was present ✔ This avoids looping and works in constant time ⏱ Complexity: Time: O(1) Space: O(1) 📚 Key Learning: A number is a power of 2 if it has exactly one set bit in binary representation. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #135DaysOfCode #BitManipulation #LeetCode

🚀 Day 61 of my DSA Journey Today’s problem: Reverse Linked List 🔁 This is one of those classic problems that really tests your understanding of pointers and how data structures work internally. 💡 What I learned: How to reverse links instead of values Importance of using prev, curr, and next pointers How in-place algorithms help optimize space ⚡ Approach in short: Traverse the list once, and keep reversing the direction of each node step by step. 📊 Complexity: Time: O(n) Space: O(1) 🧠 Takeaway: DSA is not about memorizing solutions, it’s about understanding patterns. Every problem adds a new piece to the puzzle. Consistency > Motivation 💯 #DSAJourney #100DaysOfCode #Java #LeetCode #Coding #ProblemSolving #LinkedList #KeepLearning

=> Day 20/90 DSA Journey Solved: Count Odd Numbers in an Interval (LeetCode 1523) Instead of using loops, I applied a simple mathematical formula to achieve an O(1) solution. 🔹 Key Idea: Count of odd numbers between low and high can be calculated directly using: -> ((high + 1) / 2) - (low / 2) 🔹 Why this works: -> It efficiently counts odds up to high and subtracts odds before low. 🔹 Example: Input: low = 3, high = 7 Output: 3 (Odd numbers → 3, 5, 7) -> Time Complexity: O(1) -> Space Complexity: O(1) #Java #DSA #LeetCode #ProblemSolving #Coding #Optimization