Recursion Pattern in DSA: Solve Smaller Problems

🚀 Day 9/30 – DSA Consistency Journey 🔎 Problem 52: LeetCode 2529 – Maximum Count of Positive Integer and Negative Integer Today I solved an interesting problem that looks simple but becomes powerful when optimized correctly using Binary Search 💡 🧠 Problem Summary Given a sorted array (non-decreasing order), return the maximum between: Number of positive integers Number of negative integers ⚠️ Note: 0 is neither positive nor negative. 💡 Key Insight Since the array is already sorted, we can avoid linear traversal and solve it in O(log n) time. Instead of counting manually, I used the Lower Bound (Binary Search) technique: ✔ First index of 0 → gives count of negative numbers ✔ First index of 1 → helps calculate positive numbers Then simply return the maximum of both counts. 👨💻 Approach Used Created a reusable leftmost() function Applied binary search to find boundary positions Calculated counts using index math Time Complexity: O(log n) Space Complexity: O(1) 📌 What I Practiced Today ✔ Binary Search Optimization ✔ Lower Bound Concept ✔ Boundary Handling ✔ Writing Cleaner, Efficient Code 📊 Progress Update: ✅ 52 Problems Completed 📅 Day 9 of 30 Days DSA Challenge Every day sharpening problem-solving skills and strengthening fundamentals 🚀 Consistency > Motivation 💪 #Day9 #DSA #Java #BinarySearch #LeetCode #ProblemSolving #InterviewPrep #CodingJourney #Consistency

Day 25 of #DSAChallenge Today I moved to one of the most important patterns in DSA — Binary Search. Focused on: 🔹 Understanding the core logic behind divide and conquer 🔹 Writing a clean Binary Search template 🔹 Handling edge cases (overflow, boundaries, mid calculation) 🔹 Solving variations like First & Last Occurrence Biggest learning: Binary Search is simple in theory but powerful in application. Getting the template right makes solving variations much easier. From pointer logic in Linked Lists to boundary logic in Binary Search — steadily expanding problem-solving patterns 🚀 #DSA #Java #BinarySearch #LeetCode #ProblemSolving #InterviewPreparation #Consistency

➕ DSA Practice — Sum of Digits (Recursive Approach) Today I solved the Sum of Digits problem using a recursive approach, focusing on breaking the problem into smaller subproblems. 🔍 Key Learnings Recursion works naturally when repeatedly reducing a number. Base case handles single-digit or zero condition. At each step, extract the last digit and recurse on the remaining number. Simple problems help strengthen core recursive thinking. 🧠 Why This Problem Matters Builds strong understanding of recursion fundamentals. Frequently asked as a basic interview or concept-check problem. Helps develop confidence in thinking step-by-step. 📌 Final Takeaway Even simple recursive problems are powerful for mastering base cases, shrinking input, and stack behavior. #dsa #recursion #mathematics #problemSolving #codingpractice #java #datastructures #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

Day 33 of DSA 🚀 | Binary Search Today I worked on one of the most fundamental algorithms in problem solving — Binary Search. 🔹 Task: Given a sorted array, find the index of a target element in O(log n) time. 🔹 Key realization: Binary Search is not about guessing. It’s about eliminating half of the search space at every step. 💡 What I learned: Binary Search works only on sorted arrays Using left, right, and mid pointers helps narrow the search efficiently Calculating mid as left + (right - left) / 2 avoids overflow Clear boundary conditions (left <= right) are critical ⏱ Time Complexity: O(log n) 📦 Space Complexity: O(1) This problem reinforced how mastering basics builds the foundation for advanced algorithms. #DSA #BinarySearch #Java #ProblemSolving #LearningInPublic #Consistency

🚀 DSA Insight — Reversing an Array the Optimal Way A very common problem, but also a great test of fundamentals. Many beginners create a new array or use extra memory to reverse elements… But the most efficient solution doesn’t require any extra space 👇 🏆 Optimal Approach — Two Pointer Technique Use two pointers: left → start of array right → end of array Swap elements and move inward. swap(arr[left], arr[right]) left++ right-- We stop when pointers meet in the middle. 📊 Complexity MetricValueTime ComplexityO(n)Space ComplexityO(1)Swapsn/2💡 Why It’s Optimal To reverse an array, every element must move at least once → O(n) is unavoidable. This approach also avoids extra memory, making it optimal in both time and space. 🧠 Simple logic + strong fundamentals = efficient coding #DSA #Algorithms #CodingInterview #Java #ProblemSolving #SoftwareEngineering

DSA Journey — Day 22 Today I solved the Balanced Binary Tree problem and learned an important optimization concept. -> Problem: Check whether a binary tree is height-balanced (difference between left and right subtree height ≤ 1 for every node). -> Key Learning: Instead of calculating height separately for each node (which gives O(n²) complexity), we can combine height calculation + balance checking in a single DFS traversal to achieve O(n) time. Core Insight: Return -1 immediately when a subtree is unbalanced. This avoids unnecessary computations and makes the solution efficient. Why this matters: This problem taught me how to: Optimize brute force recursion Detect early stopping conditions Write cleaner recursive logic Growth Mindset: Every tree problem is improving my recursion intuition and problem-solving speed. #DSA #Java #CodingJourney #Recursion #LearningInPublic #WomenInTech

💻 Day 26 of #DSAChallenge Continued strengthening Binary Search by solving more advanced variations. Focused on: 🔹 Applying Binary Search on problem constraints 🔹 Understanding “Search Space Reduction” clearly 🔹 Practicing problems like Search in Rotated Sorted Array 🔹 Improving boundary handling and condition building Biggest learning: Binary Search is not just about sorted arrays — it’s about identifying monotonic patterns and reducing the search space intelligently. The more I practice, the more I realize that clarity in conditions is everything. Building precision, one problem at a time 🚀 #DSA #Java #BinarySearch #LeetCode #ProblemSolving #InterviewPreparation #Consistency

DSA daily streak | day-17 ✅Find Minimum in Rotated Sorted Array II Today, I worked on finding the minimum element in a rotated sorted array that may contain duplicates. This problem is a tricky extension of the classic binary search pattern. ✨ The idea is to: • Use modified binary search • Compare mid with high to detect the unsorted half • Carefully handle duplicates when they blur the sorted structure • Gradually shrink the search space to reach the minimum This approach avoids full linear scanning in most cases and keeps the solution efficient. #DSA #Java #ProblemSolving #LeetCode #BinarySearch #NPCI #LearningJourney

⚡ 𝗗𝗮𝘆 𝟴𝟴 𝗼𝗳 𝗠𝘆 𝟭𝟬𝟬 𝗗𝗮𝘆𝘀 𝗼𝗳 𝗗𝗦𝗔 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲! Today’s problem was rooted in number theory and divisor logic — a great way to strengthen mathematical foundations. 📌 Problem Solved: 1️⃣ Check Whether a Number is a Perfect Number A number is called perfect if it is equal to the sum of its proper divisors (excluding the number itself). Example: 6 → Divisors: 1, 2, 3 Sum = 6 ✅ (Perfect Number) ✨ Key Learnings: 🔹 Instead of checking all numbers from 1 to n-1, we can optimize by iterating only up to √n. 🔹 For every divisor i, we add both i and n/i (if distinct) to the sum. 🔹 Time Complexity improved to: ✅ O(√n) instead of O(n) 🔹 Important edge case: Numbers ≤ 1 cannot be perfect numbers. 🧠 Big Takeaway: Many math-based problems become efficient once you understand divisor symmetry. Day 88 completed — number theory getting stronger! 💪🔥 #100DaysOfCode #DSA #Java #NumberTheory #MathLogic #ProblemSolving #InterviewPreparation #LearningInPublic #Developers

Day 16 of My Daily DSA Challenge Today I solved the "3Sum" problem. This problem helped me strengthen my understanding of sorting combined with the two-pointer technique. Instead of checking every possible triplet, I learned how sorting enables smarter traversal and reduces unnecessary comparisons. Key learnings: Sorting can simplify complex search problems. Two pointers can reduce brute force solutions from cubic time to quadratic time. Handling duplicates correctly is crucial for accurate results. Each problem is improving my logical thinking and making me more comfortable with pattern-based problem solving. Staying consistent is proving to be the biggest advantage in this journey. #DSA #Java #ProblemSolving #CodingJourney #Consistency