"Combination Sum with Backtracking and Recursion"

🚀LeetCode Daily Challenge 🧩 Problem: Count Operations to Obtain Zero Problem Intuition: You are given two non-negative integers, num1 and num2. In one operation, you subtract the smaller number from the larger one. Your goal is to count how many operations are required until either of them becomes zero. Essentially, this problem simulates a repeated subtraction process, similar to how the Euclidean algorithm works for finding the GCD — but instead of stopping at the GCD, we stop when one number becomes 0 and count every subtraction step. Example Insight: Let’s take an example: num1 = 5, num2 = 2 Step 1: 5 > 2 → num1 = 5 - 2 = 3 Step 2: 3 > 2 → num1 = 3 - 2 = 1 Step 3: 2 > 1 → num2 = 2 - 1 = 1 Step 4: 1 == 1 → final subtraction makes one of them zero. Total operations = 4 Approach & Strategy: ✔ Initialize a counter ans = 0. ✔ Keep subtracting the smaller number from the larger one until they are equal. ✔ Increment the counter after each operation. ✔ Once both become equal, one final operation makes the result zero. Key Idea: This iterative subtraction continues until one of the numbers becomes zero, and each subtraction step contributes to the total operation count. 📈 Complexity Analysis: Time Complexity: O(max(num1, num2)) — since we reduce the larger number step by step. Space Complexity: O(1) — constant extra space. 🔗 Problem: https://lnkd.in/dzn6_K9U 💻 Solution: https://lnkd.in/deg7Ku7e #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

🔹 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

🚀LeetCode Daily Challenge 🧩 Problem: Check If All 1's Are at Least Length K Places Away Problem Intuition: You are given a binary array nums and an integer k. Your task is to check whether every pair of consecutive 1s in the array are at least k zeros apart. In other words, for any two indices i and j where nums[i] = nums[j] = 1, we must ensure: j - i - 1 ≥ k This guarantees enough spacing between two ’1’s. If even one pair violates this, the answer is false. Example Insight: Let’s consider: nums = [1, 0, 0, 1, 0, 1], k = 2 Positions of 1s: 0, 3, 5 Distance: Between index 0 & 3 → 3 - 0 - 1 = 2 ✔️ Between index 3 & 5 → 5 - 3 - 1 = 1 ❌ (violates the condition) Thus, the array is not valid. Approach & Strategy: ✔ First, find the index of the first occurrence of 1. ✔ Then iterate through the array: • Whenever you encounter a new 1, check the distance from the previous 1. • If the gap is less than k, return false. • Otherwise, update the last index of 1 and continue. This ensures a clean and efficient linear scan. 📈 Complexity Analysis: Time Complexity: O(n) — single pass through the array Space Complexity: O(1) — no extra space used 🔗 Problem: https://lnkd.in/dP5T3BAH  💻 Solution: https://lnkd.in/dVYvDktq #LeetCode #DSA #Cpp #Arrays #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

#DSAChallenge | #LeetCodeProgress 📌 Problem: 54.Spiral Matrix 📍 Platform: LeetCode Over the past few days, I’ve been exploring some classic yet challenging LeetCode problems — the kind that really test your understanding of logic, edge cases, and clean code design. 🧠 Problem Insight You're given a matrix, and the goal is to return all elements in spiral order — starting from the top-left corner and moving right → down → left → up, repeating this pattern until all elements are covered. ⚙️ Logic Breakdown (Step-by-Step): 1️⃣ Set boundaries: top, bottom, left, right 2️⃣ Traverse in order: → Move left to right (top row) → top++ → Move top to bottom (right column) → right-- → Move right to left (bottom row) → bottom-- → Move bottom to top (left column) → left++ 3️⃣ Continue while top <= bottom and left <= right 🧩 Key Learning Points: ✅ Strengthened my understanding of matrix boundaries and directions. ✅ Improved my ability to handle edge cases cleanly. ✅ Learned how to manage loop conditions efficiently. ⏱️ Time & Space Complexity Time Complexity: O(m × n) → Every element is visited once Space Complexity: O(1) → If output list is excluded 💡 Takeaway: In DSA, consistency beats intensity. Even small daily challenges — when done consistently — compound into stronger problem-solving intuition. 🔥 Next Up: Moving on to Rotate Image & Set Matrix Zeroes to deepen my matrix manipulation skills! #DSA #LeetCode #ProblemSolving #DataStructures #Algorithms #100DaysOfDSA #Matrix #SpiralMatrix #CodeNewbie #GrowthMindset #DailyLearning #NeverGiveUp #KeepCoding #LearningNeverStops

🚀 LeetCode Daily Challenge Complete! Just solved "Final Value of Variable After Performing Operations" - a simple yet elegant problem that teaches the value of finding shortcuts in pattern matching! 💡 Solution Approach: ✅ Iterate through all operation strings ✅ Check middle character (index 1) ✅ If '-': decrement, if '+': increment ✅ Return final value The key insight: Instead of comparing full strings ("--X", "X--", "++X", "X++"), we can observe that ALL operations have the operator in the middle position! By checking just op[1], we instantly know whether to increment or decrement. Pattern recognition: "--X" and "X--" both have '-' at index 1 → decrement "++X" and "X++" both have '+' at index 1 → increment This single-character check is more efficient than string comparisons! Time Complexity: O(n) | Space Complexity: O(1) #LeetCode #StringParsing #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #CleanCode #PatternRecognition

🔍 Day 21/50 | Back to Basics - And That's Beautiful! Today I solved "Search Insert Position" - A classic binary search problem that reminded me why mastering fundamentals is so important. 💡 The Problem: Given a sorted array and a target value, return the index if found. If not, return where it should be inserted. Required: O(log n) time complexity. 🎯 The Solution: Classic Binary Search Sometimes the most elegant solution is the simplest one: Divide the search space in half Compare middle element with target Repeat until found or space exhausted The beauty? When target isn't found, left pointer naturally points to the insertion position! ⚡ Complexity: ✅ Time: O(log n) - Required constraint met ✅ Space: O(1) - Constant space 📚 Why This Problem Matters: After tackling complex DP and bitmask problems, returning to binary search felt refreshing. It reminded me that: 1️⃣ Fundamentals are forever - Binary search is a building block for so many advanced algorithms 2️⃣ Simple ≠ Easy - Writing bug-free binary search requires attention to: Loop condition: left <= right (not left < right) Mid calculation: left + (right - left) / 2 (prevents overflow) Return value: left gives insertion position 3️⃣ Interview favorites - This is one of the most asked questions because it tests understanding of a fundamental algorithm 🔑 Key Takeaway: Don't overlook "easy" problems. They're the foundation upon which complex solutions are built. Every time I revisit binary search, I understand it a little deeper. Day 21/50 ✅ | Building strong foundations! 💪Shishir chaurasiya and PrepInsta #50DaysOfCode #CodingChallenge #LeetCode #BinarySearch #DSA #Algorithms #BackToBasics #CPlusPlus #SoftwareEngineering #ProblemSolving #TechJourney #LearningInPublic #CodingLife

✨ Day 50 of 50 Days Challenge ✨ Solved LeetCode 154: Find Minimum in Rotated Sorted Array II (Hard) 👉 Problem Statement: Given a sorted array that has been rotated between 1 and n times and may contain duplicate elements, find the minimum element in the array. The goal is to minimize operations (preferably better than O(n)). 📌 Examples: Input: nums = [1,3,5] Output: 1 Input: nums = [2,2,2,0,1] Output: 0 🔎 Approach Used: ➡️ Modified Binary Search (Handles Duplicates) 1. Initialize two pointers — start and end. 2. If elements at start, mid, and end are equal, shrink the range (start++, end--). 3. If the left half is sorted, update minEle with nums[start] and move to the right. 4. Otherwise, update minEle with nums[mid] and move to the left. 5. Continue until the minimum element is found. ✅ Complexity Analysis: Time Complexity: O(log n) on average, can degrade to O(n) (due to duplicates). Space Complexity: O(1) → Constant extra space. #50DaysChallenge #LeetCode #C++ #BinarySearch #RotatedArray #Duplicates #DSA #CodingChallenge #Algorithms

Day 24: #100DaysOfCodingChallenge 🔹📊 Today’s focus was on binary search on the answer and understanding stable sorting — perfect for optimizing solutions and maintaining element order! 🔵 LeetCode/GFG: Binary Search on Answer (Basic Example) 🚀 Difficulty: Medium ⏳ Time Complexity: O(log(max_range))** 💾 Space Complexity: O(1)** ⏱ Time Taken: 0.2 sec 🔍 Approach: Applied binary search not on array indices, but on the range of possible answers. Checked feasibility at each mid-value and narrowed down the search space — a key technique for optimization problems! 🟢 LeetCode/GFG: Stable Sort Concept (Practical) 🟢 Difficulty: Easy ⏳ Time Complexity: O(n log n)** 💾 Space Complexity: O(n)** ⏱ Time Taken: 0.2 sec 🔍 Approach: Used a sorting algorithm (like Merge Sort or stable sort in STL) that preserves the relative order of equal elements. Understanding stability is crucial for problems where order matters in secondary attributes. 💡 Reflection: Binary search on the answer transforms brute-force range checks into efficient log-time searches. Stable sorting ensures correctness in multi-criteria sorting problems — both are foundational for advanced algorithmic thinking! Thanks to Nandan Kumar Mishra Sir, Abhishek Kumar Sir, and #KRMangalamUniversity for their guidance and continuous encouragement! #100DaysOfCodingChallenge #DSA #BinarySearchOnAnswer #StableSort #Array #Sorting #CPlusPlus #ProblemSolving #CodingJourney

Day 24: #100DaysOfCodingChallenge 🔹📊 Today’s focus was on binary search on the answer and understanding stable sorting — perfect for optimizing solutions and maintaining element order! 🔵 LeetCode/GFG: Binary Search on Answer (Basic Example) 🚀 Difficulty: Medium ⏳ Time Complexity: O(log(max_range))** 💾 Space Complexity: O(1)** ⏱ Time Taken: 0.2 sec 🔍 Approach: Applied binary search not on array indices, but on the range of possible answers. Checked feasibility at each mid-value and narrowed down the search space — a key technique for optimization problems! 🟢 LeetCode/GFG: Stable Sort Concept (Practical) 🟢 Difficulty: Easy ⏳ Time Complexity: O(n log n)** 💾 Space Complexity: O(n)** ⏱ Time Taken: 0.2 sec 🔍 Approach: Used a sorting algorithm (like Merge Sort or stable sort in STL) that preserves the relative order of equal elements. Understanding stability is crucial for problems where order matters in secondary attributes. 💡 Reflection: Binary search on the answer transforms brute-force range checks into efficient log-time searches. Stable sorting ensures correctness in multi-criteria sorting problems — both are foundational for advanced algorithmic thinking! Thanks to Nandan Kumar Mishra Sir, Abhishek Kumar Sir, and #KRMangalamUniversity for their guidance and continuous encouragement! #100DaysOfCodingChallenge #DSA #BinarySearchOnAnswer #StableSort #Array #Sorting #CPlusPlus #ProblemSolving #CodingJourney

🚀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