Solved LeetCode challenge 65: Generate Parentheses with recursion and backtracking

🔹 Day 66 of #100DaysOfLeetCodeChallenge 🔹 Problem: Subsets (Power Set) Focus: Backtracking + Recursion 💡 The Challenge: Generate all possible subsets of an array with unique elements. This includes the empty set and the complete set itself! 🧠 My Approach: Implemented backtracking to build subsets incrementally: Start with an empty subset and add it to results For each element, make a choice: include it or skip it Recursively explore all combinations from current index onwards Backtrack by removing the last added element to explore other paths 📊 Complexity Analysis: ⏳ Time: O(n × 2ⁿ) — 2ⁿ subsets, each taking O(n) to copy 💾 Space: O(n) — recursion depth 📌 Example: Input: nums = [1,2,3] Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 🎯 Key Takeaway: The power set problem elegantly demonstrates how backtracking can systematically explore all combinations. Each recursive call branches into two possibilities: include or exclude the current element. Classic decision tree visualization! 🌳 Pro tip: This pattern appears in many combinatorial problems — master it once, use it everywhere! Day 66/100 complete. Two-thirds through the journey! 🚀 #LeetCode #Algorithms #Backtracking #PowerSet #DSA #CodingChallenge #TechInterview #SoftwareEngineering #100DaysOfCode #LearnInPublic

🚀Day 77 of #120_Days_leetCode Challenge ! LeetCode Problem: Find and Replace Pattern Today’s problem was all about pattern matching with bijective mappings — where we find words that match a given pattern by establishing a one-to-one relationship between letters. 🧩 Problem Summary: Given a list of words and a string pattern, return all words that match the pattern. A word matches if you can permute letters such that each letter in the pattern maps uniquely to a letter in the word. 📘 Example: Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb" Output: ["mee","aqq"] 💡 Intuition: To verify a match, we need to ensure: Each character in the pattern maps to only one unique letter in the word. No two pattern characters map to the same word character. This makes it a bijection problem — a perfect use case for hash maps. 🧠 Key Takeaways: Used two hash maps to maintain bijective character mapping. Achieved O(n * k) time complexity, where n = number of words and k = word length. Great practice for mastering string and hashmap-based logic problems. ✨ Every such problem reinforces how powerful simple mapping logic can be when applied thoughtfully. #LeetCode #ProblemSolving #CodingChallenge #DataStructures #Algorithms #ProgrammingJourney

🔹 DSA Daily | Find Equilibrium Point in an Array (C++) Today, I solved the **Equilibrium Point** problem — a classic question that tests your understanding of **prefix sums and array traversal**. 💡  Problem Statement:   Given an array, find the index where the **sum of elements on the left** is equal to the **sum of elements on the right**.   If no such point exists, return -1. Approach:   1️⃣ First, calculate the **total sum** of the array.   2️⃣ Traverse the array while keeping track of the **left sum**.   3️⃣ For each index, compute the **right sum** using the formula:     `right_sum = total_sum - left_sum - arr[i]`  4️⃣ If left_sum == right_sum, that index is the equilibrium point.  Time Complexity: O(n) — single traversal of the array   Space Complexity: O(1) — constant extra space  This problem reinforces how simple **mathematical logic** and **efficient iteration** can solve what looks like a tricky problem at first glance. 🚀  #DSA #CPlusPlus #Coding #ProblemSolving #Arrays #EquilibriumPoint #CodeEveryday #GeeksforGeeks #LeetCode #ProgrammingJourney #DataStructures #Algorithms #InterviewPrep #CodingCommunity #LogicBuilding #EfficientCode #LearnToCode #TechJourney

🚀 DSA Challenge – Day 95 Problem: Design a Stack Supporting Constant-Time Minimum Retrieval 🧩📉 This is one of those elegant data structure design problems that sharpen your understanding of stack operations and auxiliary data structures! 🧠 Problem Summary: Implement a stack that, in addition to normal stack operations, can return the minimum element in O(1) time. The stack should support: ✅ push(val) → Insert an element. ✅ pop() → Remove the top element. ✅ top() → Return the top element. ✅ getMin() → Retrieve the minimum element — in constant time! ⚙️ My Approach: I used two stacks to achieve O(1) time complexity for all operations: 1️⃣ Main Stack (stack) → Stores all elements. 2️⃣ Min Stack (minStack) → Tracks the current minimum after each insertion. 🔹 When pushing a value, compare it with the current min and push it onto minStack if it’s smaller or equal. 🔹 When popping, if the popped element equals the current minimum, remove it from minStack as well. This ensures minStack always holds the minimum element at its top. 📈 Complexity: Time: O(1) for all operations Space: O(n) for the two stacks ✨ Key Takeaway: This problem beautifully demonstrates how an auxiliary data structure can optimize operations without affecting time complexity. Sometimes, solving problems efficiently is all about keeping track of the right information. ⚙️📚 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #MinStack #DataStructures #Stack #Algorithms #Python #CodingChallenge #EfficientCode #InterviewPrep #TechCommunity #LearningEveryday

🚀 Two Pointer Technique — The Hidden Gem of Optimized Problem Solving The Two Pointer technique is one of those elegant patterns that transforms nested loops into clean O(n) solutions. It’s all about using two indices that move through your data — sometimes from opposite ends, sometimes together — to efficiently compare, partition, or traverse arrays and strings. Whether it’s finding pairs with a target sum, removing duplicates in-place, or checking for palindromes, the principle stays the same: 👉 Use movement, not brute force. Instead of restarting the search every time, the Two Pointer method lets you reuse previously processed data, dramatically reducing unnecessary computations. From array problems to linked lists, and even complex challenges like “Container With Most Water” or “3Sum,” mastering this pattern unlocks a new level of clarity and performance in your problem-solving approach. Follow Codekerdos for more algorithm deep-dives, clean code patterns, and practical insights that sharpen your developer mindset 🔥 #Algorithms #TwoPointer #ProgrammingTips #DeveloperMindset #Codekerdos #CleanCode #SoftwareEngineering #100DaysOfCode #google

Solving the Rotated Challenge: Search in Rotated Sorted Array (LeetCode 33)! 🚀 You know Binary Search is O(\log N), but what happens when the array is sorted and rotated? The standard two-pointer approach breaks down! The key insight is to realize that even though the whole array is rotated, at least one half of the array must be perfectly sorted. We exploit this property in every iteration. The Modified O(\log N) Approach: Find the midpoint, \text{mid}. Identify the Sorted Half: Check if \text{nums}[\text{left}] \le \text{nums}[\text{mid}]. If true, the left half is sorted. Otherwise, the right half is sorted. Target Check: If the \text{target} falls within the boundaries of the sorted half, we discard the other half. If the \text{target} is not in the sorted half, it must be in the unsorted half, so we discard the sorted half. This technique ensures we always cut the search space in half, maintaining the optimal O(\log N) time complexity. Always a satisfying problem to solve! #Algorithms #BinarySearch #CodingChallenge #LeetCode #TechSkills

🚀Day 68 of #120_Days_LeetCode Challenge !! 🌳 Problem-Solving with Binary Trees: Constructing from Inorder & Postorder Traversals 🌳 Today, I worked on an interesting tree reconstruction problem where the goal was to build a binary tree from its inorder and postorder traversals. 🧩 Problem Statement: Given two integer arrays — inorder: the inorder traversal of a binary tree postorder: the postorder traversal of the same tree Reconstruct and return the binary tree. 💡 Key Insight: In postorder traversal, the last element is always the root of the tree. Using a hash map for quick index lookups in the inorder sequence helps efficiently locate the root position and divide the tree into left and right subtrees. ⚙️ Approach: Build a hash map to store inorder indices for O(1) lookups. Start from the end of the postorder array (root node). Recursively construct the right subtree first, then the left subtree, since postorder processes left → right → root. 🧠 Time Complexity: O(N) 📦 Space Complexity: O(N) (for recursion + hash map) 🔗 This problem sharpened my understanding of tree traversal relationships and recursion-based construction logic — a vital concept for many tree-based algorithms in interviews and real-world parsing systems. #Coding #DSA #BinaryTree #ProblemSolving #LeetCode #TechLearning #Algorithms #ProgrammingJourney

𝗘𝘅𝗽𝗹𝗼𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 Today, I explored one of the most efficient problem-solving patterns — the 𝗧𝘄𝗼 𝗣𝗼𝗶𝗻𝘁𝗲𝗿𝘀 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 🔥 It’s a simple yet powerful concept where we use 𝘁𝘄𝗼 𝘃𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 (𝗽𝗼𝗶𝗻𝘁𝗲𝗿𝘀) to traverse data structures like arrays or strings — either 𝗳𝗿𝗼𝗺 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗱𝗶𝗿𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗼𝗿 𝗮𝘁 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘀𝗽𝗲𝗲𝗱𝘀. This technique helps reduce complex problems from O(n²) to O(n), making our solutions both faster and cleaner ⚡ I’ve documented everything with explanations and step-by-step logic here 👇 🔗 𝗚𝗶𝘁𝗛𝘂𝗯: https://lnkd.in/grDc3Zwu Let’s continue learning patterns and solving problems efficiently! 💪 #LeetCode #TwoPointers #ProblemSolving #CodingPatterns #Algorithms #DataStructures #LearningEveryday #GitHubProjects

🔹 Day 67 of #100DaysOfLeetCodeChallenge 🔹 Problem: Combination Sum Focus: Backtracking + Recursion 💡 The Challenge: Find all unique combinations of numbers that sum to a target. The twist? You can reuse the same number unlimited times! This makes it more interesting than standard subset problems. 🧠 My Approach: Used backtracking with two key decisions at each step: Pick: Include current element and explore further (stay at same index for reuse) Skip: Move to next element without including current one Base case: When we've explored all elements, check if target reached 0 Optimization: Only pick if element ≤ remaining target 📊 Complexity Analysis: ⏳ Time: O(2^t) where t = target/min(candidates) — worst case recursion tree 💾 Space: O(t) — maximum recursion depth 📌 Example: Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] Explanation: - 2+2+3 = 7 (reused 2 twice!) - 7 = 7 (single element) 🎯 Key Takeaway: The beauty of this problem lies in handling unlimited reuse. By staying at the same index when picking an element, we elegantly allow repetition without creating duplicates. This pick/skip pattern is fundamental to combinatorial backtracking! Real-world analogy: Like making change for a dollar — you can use the same coin denomination multiple times! 💰 Day 67/100 complete. Mastering backtracking, one problem at a time! 💪 #LeetCode #Backtracking #DynamicProgramming #DSA #Algorithms #CodingInterview #100DaysOfCode #SoftwareEngineering #ProblemSolving #TechCareer