Day 99 of DSA Challenge: Split Array Largest Sum with Binary Search

💡 Day 104 of My DSA Challenge – Combinations 🔷 Problem : 77. Combinations 🔷 Goal : Generate all possible combinations of k numbers chosen from the range [1, n]. Example → Input: n = 4, k = 2 Output: [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]] 🔷 Key Insight : This is a backtracking problem — where we explore all possible ways of picking elements while maintaining order and avoiding repetition. The core difference from permutations is that the order of elements doesn’t matter — [1,2] and [2,1] are the same combination. 🔷 Approach : 1️⃣ Start from the first number (idx = 1). 2️⃣ At each step, decide whether to include the current number in the combination or skip it. 3️⃣ Recursively build combinations until the list size reaches k. 4️⃣ Backtrack to explore other possibilities. 🔷 My Java Approach : Used recursion to explore all inclusion/exclusion choices. Added combinations when list size equals k. Backtracked after each recursive call to maintain correct state. 🔷 Complexity : Time → O(C(n, k)) Space → O(k) (for recursion and temporary list) This problem strengthens understanding of decision trees and combinatorial logic, which form the backbone of many recursive and dynamic programming patterns. Every problem adds a new layer to logical thinking — today, it was about choosing without caring about order, but caring deeply about structure. #Day104 #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Backtracking #Recursion #Combinations #CodingChallenge #Programming #SoftwareEngineering #Algorithms #DataStructures #TechJourney #EngineerMindset #DeveloperJourney #GrowthMindset #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

✨ Day 103 of My DSA Challenge – Permutations 🔷 Problem : 46. Permutations 🔷 Goal : Generate all possible orderings (permutations) of a given array of distinct integers. Example → Input: [1,2,3] Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 🔷 Key Insight : This problem is a classic recursion and backtracking pattern — exploring all possible arrangements by making choices and undoing them. Here’s how I approached it : 1️⃣ Recursion (Depth-First Search): Build each permutation step by step. 2️⃣ Visited Array: Track which elements have been used so far. 3️⃣ Backtracking: After exploring a path, undo the choice (remove the last element and mark it unvisited). Every recursive call expands the decision tree until all positions are filled, ensuring every unique ordering is generated. 🔷 My Java Approach : Recursive helper() function generates all permutations. Base case → when current list size equals array length. Used a boolean[] vis to manage state efficiently 🔷 Complexity : Time → O(n × n!) (since there are n! permutations and copying each list takes O(n)) Space → O(n) (for recursion and visited tracking) This problem beautifully tests recursion fundamentals, state management, and the art of backtracking — essential tools for mastering combinatorial problems. Each problem reminds me that problem-solving is less about memorizing patterns and more about learning how to think. #Day103 #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Recursion #Backtracking #CodingChallenge #Programming #SoftwareEngineering #Algorithms #DataStructures #TechJourney #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

💡 Day 97 of My DSA Challenge – Single Element in a Sorted Array 🔷 Problem : 540. Single Element in a Sorted Array 🔷 Goal : Find the single element that appears only once in a sorted array where all other elements appear exactly twice, in O(log n) time and O(1) space. 🔷 Key Insight : The array is sorted, and elements appear in pairs — except for one. We can use Binary Search on Indices : Check the mid element and compare it with neighbors. If mid is unique → return it. Otherwise, depending on whether the pair is on the left or right and the parity of the remaining elements, move left or right. This works because the single element shifts the pairing pattern in the array, allowing us to discard half the search space each time. 🔷 My Java Approach : 1️⃣ Binary search over array indices. 2️⃣ Compare mid with neighbors to detect the single element. 3️⃣ Adjust search space using parity logic. 🔷 Complexity : Time → O(log n) Space → O(1) Binary search isn’t just for sorted numbers — it can also be applied to patterns and structural properties in arrays. Recognizing such patterns allows efficient solutions even when the array has special constraints. 🚀 #100DaysOfCode #Day97 #LeetCode #DSA #Java #ProblemSolving #BinarySearch #CodingChallenge #Programming #LearnToCode #CodingLife #SoftwareEngineering #Algorithms #DataStructures #TechJourney #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #CodeNewbie #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

✨ Day 101 of My DSA Challenge – Magnetic Force Between Two Balls 🔷 Problem: 1552. Magnetic Force Between Two Balls 🔷 Goal: Place m balls into sorted basket positions such that the minimum magnetic force (i.e., minimum distance between any two balls) is as large as possible. 🔷 Key Insight: This is another brilliant Binary Search on the Answer problem. Instead of directly computing distances, we binary search for the maximum possible minimum distance that still allows placing all balls. Here’s how the logic works: 1️⃣ Sort all basket positions. 2️⃣ Use binary search on the range of possible distances (0 to max(position) - min(position)). 3️⃣ For each middle distance mid, check feasibility using a greedy approach — place balls while maintaining at least mid distance apart. 4️⃣ If it’s possible → try a larger distance. If not → reduce the distance. 🔷 My Java Approach: Implemented a helper function isPossible() to check if we can place all balls for a given minimum distance. Used Binary Search to maximize that minimum distance. 🔷 Complexity: Time → O(n × log(maxDist)) Space → O(1) This problem beautifully blends sorting, binary search, and greedy placement — showing how abstract concepts like “searching on the answer” translate into real algorithmic reasoning. Every new day strengthens my foundation in Binary Search patterns, sharpening both logic and implementation clarity. 🚀 #Day101 #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #BinarySearch #GreedyAlgorithm #CodingChallenge #Programming #SoftwareEngineering #Algorithms #DataStructures #TechJourney #LearnToCode #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

💡 Day 98 of My DSA Challenge – Longest Subsequence With Limited Sum 🔷 Problem: 2389. Longest Subsequence With Limited Sum 🔷 Goal: For each query, find the maximum number of elements from nums that can form a subsequence with a sum ≤ query value. 🔷 Key Insight: To maximize the subsequence size, we should always pick smaller elements first — this is a greedy choice. Hence, sorting the array ensures we can accumulate the smallest elements until the sum exceeds the query limit. Approach outline: 1️⃣ Sort the array nums. 2️⃣ For each query, add elements one by one until the sum crosses the limit. 3️⃣ Return the count of elements that fit within the limit. This logic can also be optimized further using prefix sums + binary search, but the greedy approach works perfectly within given constraints. 🔷 My Java Approach: Sort the array. Use a helper function to count how many elements fit under the query sum. Store each result in the answer array. 🔷 Complexity: Time → O(n log n + n × m) Space → O(1) Sometimes, simplicity wins. This problem reinforces the power of greedy thinking — starting small, building up gradually, and knowing when to stop. Recognizing such patterns is key to writing clean and intuitive code. 🚀 #100DaysOfCode #Day98 #LeetCode #DSA #Java #ProblemSolving #GreedyAlgorithm #CodingChallenge #Programming #LearnToCode #CodingLife #SoftwareEngineering #Algorithms #DataStructures #TechJourney #CodeEveryday #EngineerMindset #DeveloperJourney #GrowthMindset #CodeNewbie #KeepLearning #ApnaCollege #AlphaBatch #ShraddhaKhapra

🌟 Day 44 – LeetCode Practice Problem: Product of Array Except Self (LeetCode #238) 📌 Concept: Given an integer array, create a new array where each element equals the product of all other elements except itself, without using division. 🧠 My Approach: First pass → compute prefix products (multiply everything before current index) Second pass → compute suffix products (multiply everything after current index) Combine both to get the result for each index efficiently No extra multiplication array used — optimized and clean logic ⚡ This avoids division and runs in linear time — exactly what the problem demands ✅ 📈 Result: ✅ Accepted ⚡ Runtime: 2 ms (Beats ~87%) 📦 Memory: Efficient usage 💡 Key Learning: This problem reinforces the power of prefix & suffix computation — a common trick in array manipulation + interview favorite. Great way to improve problem-solving without relying on brute force or division. --- 🚀 Growing stronger every day in DSA! #LeetCode #DSA #Java #ProblemSolving #PrefixSuffix #CodingJourney #ArrayProblems #LearningMindset

🚩 Problem: 46. Permutations 🔥 Day 49 of #100DaysOfLeetCode 🔍 Problem Summary: Given an array nums of distinct integers, return all possible permutations in any order. 🧠 Intuition: A permutation is a rearrangement of elements. We can use backtracking to explore all possible arrangements: Build partial permutations recursively. Add unused elements one by one. Backtrack after exploring each path. ✅ Approach (Backtracking): Use a temporary list to store the current permutation. If its size equals nums.length, add it to the result. For each element, if not already in the temp list, choose it and recurse. Backtrack by removing the last chosen element. ⚙️ Performance: ⏱️ Runtime: 1 ms 🚀 💪 Beats: 99.95% of Java solutions 💾 Memory: 44.5 MB ⚡ (Beats 91.87% of users) 📊 Complexity: Time Complexity: O(n × n!) Space Complexity: O(n) (recursion stack + temporary list) ✨ Key Takeaway: This problem builds a solid foundation in backtracking, teaching how to systematically generate all possible outcomes through recursive exploration and reversal. Link:[https://lnkd.in/gncncqK8] #100DaysOfLeetCode #Day49 #Problem46 #Permutations #Backtracking #Recursion #DSA #Algorithms #Java #LeetCode #ProblemSolving #CodingChallenge #InterviewPreparation #CrackingTheCodingInterview #CodingCommunity #SoftwareEngineering #DataStructures #DeveloperJourney #ArjunInfoSolution #Programming #CodeNewbie #LearnToCode #TechCareers #CareerGrowth #ComputerScience #CodeEveryday #ZeroToHero #CodingIsFun #CodeLife #JavaDeveloper #GameDeveloper #Unity #AI #MachineLearnin

🚩 Problem: 41. First Missing Positive 🔥 Day 54 of #100DaysOfLeetCode 🔍 Problem Summary: Given an unsorted integer array nums, return the smallest positive integer that is missing. You must solve it in O(n) time and O(1) extra space. This is one of the most elegant and clever array manipulation problems. 🧠 Intuition: Key observations: The answer must be in the range [1, n+1] We want each number x (1 ≤ x ≤ n) to be placed at index x - 1 This leads to the index marking / cyclic placement trick: Iterate through the array Place each number x into its correct position: At index x - 1 By swapping until the number is either out of range or already in correct place After rearrangement, the first index i where nums[i] != i + 1 gives the answer If all numbers are in correct places → answer is n + 1 Simple idea, extremely powerful.⚙️ Performance: ⏱️ Runtime: 2 ms 🚀 💪 Beats: 99.8% of Java solutions 💾 Memory: 56 MB ⚡ (Beats 95% of users) 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) ✨ Key Takeaway: This problem teaches the Cyclic Sort pattern — an essential technique for problems involving: Missing numbers Duplicates Correct placement In-place array rearrangement Mastering this trick gives you an edge in advanced array manipulation question Link:[https://lnkd.in/gV8y8dhc] #100DaysOfLeetCode #Day54 #Problem41 #FirstMissingPositive #CyclicSort #IndexMapping #Algorithms #DSA #Java #LeetCode #ProblemSolving #CodingChallenge #InterviewPreparation #CrackingTheCodingInterview #SoftwareEngineering #CodingCommunity #DataStructures #DeveloperJourney #ArjunInfoSolution #TechCareers #CareerGrowth #Programming #CodeNewbie #ComputerScience #LearnToCode #ZeroToHero #CodingIsFun #CodeLife #JavaDeveloper #GameDeveloper #Unity #AI #MachineLearning

🎯 Day 15 – Check if Two Strings Are Anagrams Today’s DSA challenge focuses on verifying whether two given strings are anagrams — meaning they contain the same characters in the same frequency but arranged differently. This is a classic problem that strengthens your understanding of string manipulation, frequency counting, and clean logic building. 💡 Key Learning: Anagram problems help you understand important concepts like ASCII-based frequency arrays, character traversal, and efficient string comparison. These micro-skills boost your ability to solve interview-level string problems involving frequency maps and pattern-based checks. 🧠 Concepts Used: Strings Character frequency counting ASCII-based array mapping Linear traversal Conditional logic ⏱️ Time Complexity: O(n) 📘 Space Complexity: O(1) (using fixed-size array) 💬 Each challenge improves your confidence in writing optimized, readable logic — a skill that reflects directly in coding rounds, debugging tasks, and backend development. #Day15 #DSA #Java #CodingChallenge #StringProblems #KeepLearning

Today’s DSA Practice — Binary Trees 🌳 Today, as part of our university-provided DSA practice course, I worked through a complete Binary Tree coding module! It was an amazing hands-on session that helped me strengthen both my recursion and tree traversal concepts. Here are the key problems I practiced: Create a Binary Tree from an Array Level Order Traversal Print Nodes at Odd Levels Iterative Inorder Traversal Recursive Inorder, Preorder & Postorder Traversals Count Leaf & Non-Leaf Nodes Print All Root-to-Leaf Paths Convert a Tree to its Mirror Check if the Tree is Foldable Check if Two Trees are Identical Find Maximum Depth or Height Evaluate an Expression Tree Each problem added great clarity to how tree structures and recursive algorithms actually work in practice. #DSA #BinaryTree #CodingPractice #Java #Recursion #ProblemSolving #DataStructures #LearningJourney