Solved #100DaysOfCode problem: Count Operations to Obtain Zero in Java

Day 40 of #100daysOfCode Problem: 2654. Minimum Number of Operations to Make All Array Elements Equal to 1 Difficulty: Medium Language: Java Status: Solved Problem Summary: You're given an array of positive integers nums. In one operation, you can choose an index i (where 0 ≤ i < n - 1) and replace either nums[i] or nums[i+1] with gcd(nums[i], nums[i+1]). You need to find the minimum number of operations to make all elements equal to 1. If it’s not possible, return -1. Key Insight: If there’s at least one 1 in the array → we can convert all other elements to 1 in n - count(1) operations. Otherwise, find the shortest subarray whose GCD = 1. Once found, it takes (j - i) operations to create one 1 and (n - 1) more to make the entire array 1. Algorithm Steps: Count how many elements are 1. If any exist → answer = n - ones. If not → iterate all subarrays, compute GCD until it becomes 1. Keep track of the smallest subarray length that reaches GCD = 1. If none found → return -1. Else return minLength + (n - 1). Time Complexity: O(n² * log(max(nums[i]))) Space Complexity: O(1) Learning Takeaway: Classic GCD reduction logic—search for minimal segment that can “spread” ones across the array. Efficiently reuses math logic in algorithmic reasoning. #Day40 #100DaysOfCode #LeetCode #Math #GCD #Greedy #Java #Algorithms #CodingChallenge #ProblemSolving #DSA

🚀Day 39/100 - Problem of the day :- Minimum Number of Operations to Make all Array Elements Equal to 1. 🎯 Goal: Solved a problem on LeetCode involving finding the minimum operations to make all elements equal using the GCD (Greatest Common Divisor) approach in Java. 💡 Core Idea: The key insight was to use the Euclidean algorithm to compute GCD efficiently and track how many operations are needed based on the number of 1’s and the resulting GCD values within the array. 📘 Key Takeaway: Optimizing logic with mathematical properties (like GCD) can simplify problems that seem complex at first. Understanding patterns in number theory helps unlock elegant solutions for array manipulation problems. 🧠 Time Complexity: O(n²) — due to nested iteration and repeated GCD calculations. 💾 Space Complexity: O(1) — only a few integer variables are used; no extra data structures needed. #100DaysChallenge #DSA #Java #Day39 #Leetcode #SolvingProblem #CodingJourney

✨ 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 35 — Maximize the Minimum Powered City Problem: 2528. Maximize the Minimum Powered City Difficulty: Hard Language: Java Status: Solved This problem was a deep dive into binary search on the answer combined with sliding window logic — a very common yet tricky combo for optimization-based problems. Key Idea: Use binary search to guess the minimum power each city can have. Verify feasibility using a greedy + prefix/sliding window approach to distribute additional power stations efficiently. Carefully maintain a running window sum to ensure we don’t exceed the limit k of extra stations. What I Learned: How to apply binary search beyond sorted arrays — especially on the answer space. The importance of balancing precision and efficiency while handling prefix sums and range updates. Got a better intuition for “can we achieve X?” style feasibility functions. These kinds of problems are perfect for strengthening logic and optimization thinking. #Day35 #100DaysOfCode #LeetCode #DSA #BinarySearch #SlidingWindow #GreedyAlgorithm #Java #ProblemSolving #Algorithms #CodingChallenge #ProgrammingJourney #SoftwareEngineering #CodeEveryday

🗓 Day 8/ 100 – #100DaysOfLeetCode 📌 Problem 3234: Count the Number of Substrings With Dominant Ones A substring is said to have dominant ones if: 👉 #1s ≥ (#0s)² The task is to count how many substrings in the binary string satisfy this condition. 🧠 My Approach: 🔹 Iterated through substrings while maintaining counts of zeros and ones. 🔹 Used the condition ones ≥ zeros² to determine whether a substring is valid. 🔹 Applied early stopping when the zero count became too large, since the quadratic requirement makes dominance increasingly difficult to achieve. 🔹 This pruning significantly reduced unnecessary checks and improved the overall efficiency. ⏱ Time & Space Complexity Time Complexity: O(n · √n) Because for each starting index, we only explore substrings until the zero count reaches ~√n (beyond which zeros² becomes too large to satisfy). This is a major improvement over the brute-force O(n²). Space Complexity: O(1) Only uses a few counters (ones, zeros, indices). 💡 Key Learning: This problem beautifully shows how mathematical constraints can simplify substring evaluation. Recognizing that zeros affect the condition quadratically helped guide a smarter pruning strategy, turning an expensive brute-force check into something efficient and elegant. #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

📌 Day 8/100 - Search Insert Position (LeetCode 35) 🔹 Problem: Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be inserted in order. 🔹 Approach: I used a binary search approach for efficiency 🔍 1️⃣ Start with two pointers — low and high. 2️⃣ Find the mid index and compare nums[mid] with the target. 3️⃣ If target equals nums[mid], return mid. 4️⃣ If target is smaller, move the high pointer left. 5️⃣ If target is greater, move the low pointer right. 6️⃣ When the loop ends, low gives the correct insert position. 🔹 Key Learning: Binary Search saves time — reducing O(n) to O(log n)! Understanding the condition when to move left/right is key. Even simple problems sharpen logical precision and boundary handling. Each problem strengthens the logic muscle 🧠 — one step closer to mastering algorithms! 💪 #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney #LearnByDoing

💻 DSA – Day 8: Patterns (Part II – Advanced) Today I explored some of the most interesting and visually appealing pattern problems in Java. These patterns may look simple, but they’re powerful for improving logic, nested loop control, and thinking in terms of rows & columns. 🔶 What I covered today 🔹 Hollow Rectangle Pattern Learned how to combine borders + spaces using conditions. 🔹 Inverted & Rotated Half Pyramid Understanding how rotation affects alignment and spacing. 🔹 Inverted Half Pyramid (Numbers) Patterns that change not just shape, but also the values printed. 🔹 Floyd’s Triangle A classic pattern where numbers increase continuously row by row. 🔹 0–1 Triangle Pattern Great for applying simple mathematical logic to create alternating values. 🔹 Butterfly Pattern One of the most beautiful patterns—perfect symmetry with increasing and decreasing stars. 🔹 Solid Rhombus Pattern Focused on leading spaces + full rows. 🔹 Hollow Rhombus Pattern Combining spacing + boundary conditions for a clean hollow shape. 🔹 Diamond Pattern A combination of upward and downward pyramids to form a centered diamond. 🧠 Why these patterns matter? They sharpen: logical thinking loop flow understanding condition-based pattern design confidence before moving to arrays & recursion 🚀 Consistency is building momentum Loving how each pattern improves the way I think about problems. Next up: more DSA fundamentals. #DSA #Day8 #Java #Patterns #AdvancedPatterns #CodingJourney #100DaysOfCode #LearningInPublic #ProblemSolving

🗓 Day 6 / 100 – #100DaysOfLeetCode 📌 Problem 2169: Count Operations to Obtain Zero The goal was to determine how many operations are needed to make both numbers zero by repeatedly subtracting the smaller one from the larger. 🧠 My Approach: Implemented the Euclidean Algorithm to optimize repeated subtraction. Instead of subtracting multiple times, used the modulus operator (%) to reduce steps efficiently. Counted the total number of operations until one of the numbers reached zero. ⏱ Time Complexity: O(log(min(a, b))) 💾 Space Complexity: O(1) 💡 Key Learning: This problem reinforced how mathematical insights like the Euclidean Algorithm can transform a brute-force approach into an elegant, optimized solution. It also reminded me of how language syntax (like Java’s integer operations) shapes the implementation of algorithmic logic. Each day brings a small improvement — and that’s what makes this journey meaningful 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Java #ProblemSolving #Algorithms #EuclideanAlgorithm #MathInCoding #DataStructures #DSA #CodingJourney #CompetitiveProgramming #SoftwareEngineering #CodeEveryday #LearningInPublic #DeveloperJourney #TechStudent #CodingCommunity #CareerGrowth #Programming #LogicBuilding #Optimization #KeepLearning

📌 Day 51/100 – Longest Word in Dictionary (LeetCode 720) 🔹 Problem: Given an array of words, find the longest word that can be built one character at a time by other words in the array. If multiple results exist, return the lexicographically smallest one. 🔹 Approach: Built a Trie structure to store all words. Used DFS traversal to explore all valid prefixes (where every prefix forms a valid word). Updated the answer when a longer or lexicographically smaller valid word was found. 🔹 Key Learning: Deepened understanding of Trie traversal with DFS. Practiced combining lexicographical comparison with prefix validation. Reinforced prefix-based word-building logic efficiently. 🔹 Complexity: Time: O(N × L) — N = number of words, L = average word length Space: O(26 × N × L) — for Trie storage #Day51Of100 #LeetCode720 #100DaysOfCode #Java #DSA #Trie #DFS #ProblemSolving #CodingChallenge #Strings #DataStructures #CodingJourney #KeepLearning