Generated Parentheses with Backtracking and Recursion

🚀 Day 37 of #100DaysOfCode Challenge 🚀 🧠 Problem: 🧩 LeetCode 282 — Expression Add Operators (Hard) This problem was all about exploring backtracking with arithmetic logic. We’re given a string of digits and need to insert +, -, or * between them to reach a target value. ⚙️ Approach Used backtracking to: -Pick every possible substring as the next number. -Try adding each operator before it (+, -, *). -Track three things: -current value → total so far -previous operand → to handle multiplication correctly -expression → the string we’re building -Also skipped invalid paths like numbers with leading zeros. 📘 Learning -Understood how to evaluate expressions on the fly without using eval(). -Learned to manage operator precedence (* before +/-) using recursion and previous operand adjustment. -Realized that some problems can’t be optimized further — they test how well you can prune and organize recursion. #100DaysOfCode #DSA #CodingChallenge #StriversSheet #ProblemSolving #TakeUForward  #Recursion #CodingInterview #ProgrammingTips #LeetCode  #Backtracking 

Day 105 of 365 of Solving LeetCode Problems! ✅ Generate All Binary Strings: Given an integer n, generate all binary strings of length n representing bits. Return the strings in ascending order. Key Observations: 1) This is a classic recursion and backtracking problem — each position can either be '0' or '1'. 2) You explore both possibilities recursively until the string reaches length n. 3) The order of recursive calls ('0' first, then '1') ensures the results are in lexicographical (ascending) order. 4) Time complexity is O(2^n) since there are 2^n possible binary strings. #Recursion #Backtracking #LeetCode #DSA 

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

Day 46 — #100DaysOfLeetCode 🚀 Problem: Remove Duplicate Letters (LeetCode 316) ✅ Approach: Used a Stack + Greedy approach to build the smallest lexicographical string with unique letters. ⚡ Complexity: O(n) Learning: Strengthened understanding of stack-based string manipulation and greedy logic 🔠 #LeetCode #100DaysOfCode #DSA #Strings #Stack #GreedyAlgorithm #ProblemSolving #CodingJourney

🚀 Day 125 of #LeetCode Challenge! Problem: Binary Tree Preorder Traversal 💡 My Approach: The goal is to perform a preorder traversal of a binary tree — visiting nodes in the order: Root → Left → Right Here’s the step-by-step logic: Start from the root node. Visit (record) the root value first. Recursively traverse the left subtree, then the right subtree. Store values in a vector as you go. ✨ Example Input: [1, null, 2, 3] Output: [1, 2, 3] 🧠 Key Idea Preorder traversal is useful when you need to copy or serialize a tree — it captures the structure starting from the root. ⏱ Complexity TypeValueTimeO(N) — each node visited onceSpaceO(H) — recursion stack (H = height of tree) 📎 GitHub Link: https://lnkd.in/gZ6GeXzm #LeetCode #BinaryTree #PreorderTraversal #Recursion #DSA #C++ #ProblemSolving #CodingChallenge #Day125

🧩 LeetCode Challenge – Day 72 ✅ Dived into a string decoding problem today — a perfect blend of stacks, recursion, and pattern tracking. 🔗 LeetCode 394 – Decode String This challenge revolves around decoding expressions like 3[a2[c]], requiring careful handling of nested patterns and character reconstruction. It’s a great exercise in managing multiple layers of logic — keeping track of counts, substrings, and the overall decoded output step by step. 💡 Key Takeaways: • Stack-based parsing builds precision in handling nested structures. • Breaking problems into layers simplifies even the most complex logic. • Attention to detail is everything — one misplaced index can change the entire output. #Day72 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Stack #Strings #Parsing #Recursion

#Day67 of my LeetCode Journey 🚀   Starting with Recursion problems !  🧩 Question #8 – String to Integer (atoi) (Medium)  Brute Force Approach:   1) Convert the string manually step-by-step remove whitespaces, handle signs, read digits, and clamp values.   2) Check for invalid inputs and handle edge cases like overflow/underflow explicitly.   3) Use iterative parsing to process characters sequentially.   - Time Complexity: O(N)   - Space Complexity: O(1)  Optimal (Recursive) Approach:   1) Use recursion to simplify the parsing process each helper function handles one part (like skipping spaces, checking sign, removing zeros, or reading digits).   2) Extract digits recursively until a non-numeric character appears.   3) Convert digits to an integer and clamp it within the 32-bit signed range.   - Time Complexity: O(N)   - Space Complexity: O(N) (due to recursive calls)  ✨ That’s it for Day 67. The journey continues — see you on Day 68. Happy coding! 🚀 #Day67 #LeetCodeJourney #LeetCode #Recursion #String #Atoi #Python #DSA #CodingPrep

🔍 Day 66 of #100DaysOfCode 🔍 🔹 Problem: Binary Search – LeetCode ✨ Approach: Implemented an iterative binary search to efficiently locate the target element within a sorted array. By halving the search range each time — adjusting low and high around the mid-point — the algorithm achieves blazing-fast lookups! ⚡ 📊 Complexity Analysis: Time Complexity: O(log n) — array size halves with each iteration Space Complexity: O(1) — constant extra space ✅ Runtime: 0 ms (Beats 100.00%) ✅ Memory: 46.02 MB 🔑 Key Insight: Binary Search is proof that efficiency isn’t about doing more — it’s about eliminating what’s unnecessary. 🚀 #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #BinarySearch #LogicBuilding #Efficiency #ProgrammingChallenge #CodeJourney #CodingDaily

🔹 Day 70 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Combination Sum III 🔑 Topic: Backtracking 🧠 Approach: We need to find all combinations of k distinct numbers (1–9) that sum to n. Here’s how I solved it 👇 Use backtracking to explore all combinations starting from 1 to 9. Add the number and move forward recursively, reducing both k (count) and n (target). Stop when k == 0 and n == 0 → valid combination found! Backtrack by removing the last number and continue exploring. ⏳ Time Complexity: O(2⁹) ≈ O(512) 💾 Space Complexity: O(k) (recursion + temp list) 📌 Example: Input: k = 3, n = 9 Output: [[1,2,6],[1,3,5],[2,3,4]] ✅ 🎯 Takeaway: This problem teaches the power of controlled recursion — when both depth and sum conditions guide the search efficiently. 💡 #LeetCode #DSA #Backtracking #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀

🔹 Day 69 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Subsets II 🔑 Topic: Backtracking 🧠 Approach: The task is to find all unique subsets of an array that may contain duplicates. Here’s the step-by-step logic 👇 Sort the array first to bring duplicates together. Use backtracking to explore every possible subset. Skip duplicates by checking if the current element equals the previous one at the same recursion depth. Add every subset (including empty) to the result list. ⏳ Time Complexity: O(2^n) 💾 Space Complexity: O(n) (recursion stack + temp list) 📌 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] ✅ 🎯 Takeaway: Sorting and skipping duplicates isn’t just for combinations — it’s the secret weapon for clean subset generation too! ⚡ #LeetCode #DSA #Backtracking #Subsets #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀