Maximize Operations to Move Ones to End in Binary String

📌 Day 4/100 - Minimum Size Subarray Sum (LeetCode 209) 🔹 Problem: Given an array of positive integers and a target value, find the minimal length of a contiguous subarray whose sum is greater than or equal to the target. If there’s no such subarray, return 0. 🔹 Approach: Used the Sliding Window technique for an optimized solution: Initialize two pointers (low, high) and a running sum. Expand the window by moving high until the sum ≥ target. Once valid, shrink the window from the left to find the smallest subarray. Keep updating the minimum length throughout. This reduced the time complexity from O(n²) (brute force) to O(n). 🔹 Key Learning: Sliding Window is ideal for problems with contiguous subarrays. Optimization often comes from adjusting the window efficiently. Each problem strengthens logical flow and pattern recognition. Another step forward in mastering DSA and problem-solving consistency! ⚡ #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingChallenge #SlidingWindow

Day 39 of #100DaysOfCode 💻🔥🚀 Problem: Number of Arithmetic Slices ➕📈 💡 My Intuition: Imagine you’re tracking a sequence of numbers — if the difference between consecutive elements stays constant, it forms an arithmetic slice. Initially, I solved it using a difference array to find equal gaps, but later realized it can be done much more elegantly by just keeping two counters: curr → tracks current streak of arithmetic slices total → keeps cumulative count of all slices Whenever you find three numbers forming an arithmetic pattern, increment curr and add it to total. If the pattern breaks, reset curr to 0 and continue. ⚙️ Takeaway: Optimization isn’t always about writing more code — sometimes, it’s about recognizing a simple hidden pattern that makes the logic effortless ⚡ ✨ Keep learning. Keep refining. Every optimized line sharpens your thinking 💪🔥 #Day39 #100DaysOfCode #LeetCode #DSA #Java #CodingJourney #ProblemSolving #KeepPushing #GrindNeverStops

📌 Day 153 of Coding - Maximum Frequency of an Element After Operations I (LeetCode - Medium) 🎯 Goal: Given an integer array nums, an integer range k, and a number of operations, determine the maximum possible frequency of any number after performing up to numOperations modifications - where each operation can change a number by at most k. 💡Approach & Debugging: Found the maximum value in the array and created a frequency prefix array. For each possible target value i, calculated the total numbers within the [i - k, i + k] range. The frequency of i could be increased using available operations on nearby elements. Kept track of the best achievable frequency. ✔️ Time Complexity: O(N + M) - where M is the value range up to max(nums) + k. ✔️ Space Complexity: O(M) 🧠Key Takeaways: Prefix sums + frequency arrays are powerful for range-based computations. Always optimize loops around range-based frequency calculations. #Day153 #LeetCode #Arrays #PrefixSum #Frequency #Java #ProblemSolving #DSA #CodingChallenge #Algorithms #100DaysOfCode #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife

📌 Day 159 of Coding - Make Array Elements Equal to Zero (LeetCode - Easy) 🎯 Goal: Given an integer array nums, find the number of valid starting positions and directions such that by repeatedly decrementing and reversing direction (based on the rules), all elements eventually become 0. 💡Approach & Debugging: First computed total sum using Arrays.stream(nums).sum(). Maintained two prefix sums : left and right. For each index i where nums[i] == 0: Incremented left and decremented right progressively. Checked whether the left and right sums balance according to the movement rules. Counted valid selections when the balance was perfect or off by just one. ✔️ Time Complexity: O(N) - single pass through the array. ✔️ Space Complexity: O(1) - constant extra space. #Day159 #LeetCode #Simulation #Arrays #PrefixSum #Java #ProblemSolving #DSA #CodingChallenge #100DaysOfCode #Algorithms #InterviewPrep #SoftwareEngineering #DataStructures #CodeNewbie #ProgrammersLife

💡 Day 57 of #100DaysOfCode 💡 Today, I solved LeetCode Problem #217 – Contains Duplicate 🧩 Given an integer array, the task is simple yet fundamental: 👉 Determine whether any value appears at least twice in the array. 💻 Language: Java ⚡ Runtime: 13 ms — Beats 87.70% 🚀 📉 Memory: 58.28 MB — Beats 63.02% 🧠 Key Learnings: Reinforced my understanding of HashSet and its O(1) lookup time. Learned how sets help efficiently identify duplicates in large datasets. Strengthened array traversal and data structure optimization skills. 🧩 Approach: 1️⃣ Initialize an empty HashSet. 2️⃣ Iterate through each element in the array. 3️⃣ If an element already exists in the set → return true. 4️⃣ Else, add it to the set. 5️⃣ If loop completes, return false. ✅ Complexity: Time: O(n) Space: O(n) ✨ Takeaway: Even basic problems like these teach the power of hash-based structures — simple yet powerful for building optimized systems and preventing redundant computations. #100DaysOfCode #LeetCode #Java #DataStructures #HashSet #ProblemSolving #CodingChallenge #CleanCode #Programming #SoftwareEngineering #TechLearning #Algorithms

🚀 Day 412 of #500DaysOfCode 🧩 Problem: 3542. Minimum Operations to Convert All Elements to Zero Platform: LeetCode (Medium) 📘 Problem Statement: Given an array of non-negative integers, you can perform operations where you select a subarray and set all occurrences of the minimum number in that subarray to 0. Your goal is to find the minimum number of operations required to convert all elements in the array to 0. 💡 Example: Input: nums = [3,1,2,1] Output: 3 Explanation: 1️⃣ Select [1,3] → set 1s to 0 → [3,0,2,0] 2️⃣ Select [2,2] → set 2 to 0 → [3,0,0,0] 3️⃣ Select [0,0] → set 3 to 0 → [0,0,0,0] ⚙️ Intuition: Each continuous non-zero segment in the array represents one operation. Zeros act as boundaries that divide these segments. Hence, the minimum number of operations equals the count of continuous non-zero segments. 🧠 Approach: Iterate through the array. Count the number of times a new non-zero segment starts → (when nums[i] != 0 and (i == 0 || nums[i-1] == 0)). 🕒 Complexity: Time: O(n) Space: O(1) 🔥 Learned how identifying segment patterns in arrays can lead to simple and efficient solutions! #Day412 #LeetCode #Java #CodingChallenge #ProblemSolving #DSA #Programming #100DaysOfCode #500DaysOfCode #CodeNewbie #Developers

#Day5 of #100DaysOfCode Challenge! 🔥 Today’s focus is on strengthening array fundamentals through two challenging problems: Missing Number and First Repeating Element. Problem 1: LeetCode 268 – Missing Number Objective: Identify the missing number in an array containing n distinct numbers ranging from 0 to n. Approach: Utilized the sum formula, n*(n+1)/2, to calculate the expected sum. By subtracting the actual sum of the array elements, the missing number was readily identified. Time Complexity: O(n) | Space Complexity: O(1) This solution is concise, elegant, and exemplifies a clean approach to solving interview problems. Problem 2: First Repeating Element (GFG) Objective: Determine the first repeating element with the smallest index (1-based). Approach: Traversed the array from right to left, utilizing a HashSet to store elements. Whenever a number was encountered that was already present in the HashSet, the index was updated to ensure the smallest possible value. Time Complexity: O(n) | Space Complexity: O(n) Key Takeaway: Recognizing when a mathematical shortcut, such as the sum formula, is applicable versus when a data structure, like a HashSet, is necessary, cultivates strong problem-solving intuition. Balancing simplicity and optimization is crucial for achieving significant growth in problem-solving skills. Thank you Rajesh Gupta for your assistance in guiding me through this process. #100DaysOfCode #LeetCode #DSA #ProblemSolving #Arrays #CodingChallenge #LearningInPublic #Java #Programming

🚀 Today’s #Learning: Solved the Climbing Stairs problem 🪜 using Dynamic Programming (Memoization) in #Java 📘 Problem: Given n stairs, you can climb either 1 or 2 steps at a time. How many distinct ways can you reach the top? ❌ Time Complexity: O(2ⁿ) ❌ Space Complexity: O(n) (due to recursion stack) 🧠 Approach 2 — DP with Memoization (Top-Down): Optimized by storing already computed results to avoid re-computation 👇 ✅ Time Complexity: O(n) ✅ Space Complexity: O(n) (DP array + recursion stack) 💡 Next Step: Convert it to a space-optimized bottom-up approach with O(1) space. 🧠 Approach 3 — Space Optimized (Bottom-Up DP) We only need the last two results at any time — just like Fibonacci. ✅ Time Complexity: O(n) ✅ Space Complexity: O(1) ⚙️ Super efficient — perfect for large inputs. 💬 Reflection: Loved how this problem builds intuition for Fibonacci-style DP and space optimization. Every step in #DSA makes problem-solving faster and more intuitive! #Java #DSA #DynamicProgramming #ProblemSolving #Algorithms #CodingPractice #SpaceOptimization #LearningEveryday #Striver #Preparation #Leetcode #Programming #Java #DSA #DynamicProgramming #ProblemSolving #Algorithms #CodingPractice #SpaceOptimization #LearningEveryday #Striver #Preparation #Leetcode #Programming

🧩 Day 78 of #100DaysOfCode Challenge 🧩 📘 LeetCode 56 — Merge Intervals Topic: Arrays & Sorting Today’s problem was about merging overlapping intervals — a real test of logical thinking and array manipulation skills! 💡 Problem Summary: Given multiple intervals, the goal is to merge all overlapping ones and return a list of non-overlapping intervals that cover all ranges in the input. ⚙️ Approach (Brute + Optimized): 1️⃣ Sort all intervals based on their start value. 2️⃣ Compare the current interval with the previous one: If they overlap, merge them by updating the end time. If not, add the previous interval to the result. 3️⃣ Continue until all intervals are processed. 🧠 Key Learning: Sorting simplifies overlapping detection. Interval-based problems help strengthen array and logic handling. Real-world application: scheduling problems and timeline merging! ✨ Each problem is another step toward mastering patterns in DSA. #Day78 #LeetCode #100DaysOfCode #Java #DSA #ProblemSolving #WomenInTech #CodingJourney #Arrays #Sorting

🎯 Day 8 of #365DaysofDSA Today I solved “Convert Sorted Array to Binary Search Tree” (LeetCode #108) 🌲 💡 Concepts used: • Recursion • Divide and Conquer • Binary Search Tree Construction ✨ Approach Summary: The goal is to convert a sorted array into a height-balanced BST. To maintain balance, I picked the middle element of the array as the root — ensuring roughly equal elements on both sides. Then recursively repeated the process for left and right halves of the array. For each recursive call: 1️⃣ Find the middle index of the current subarray. 2️⃣ Create a node with that middle element. 3️⃣ Recursively build left and right subtrees using the respective halves. 🚀 Key takeaway: The divide and conquer strategy naturally fits problems that require balance and recursion — just like in this BST construction. Breaking a big problem into symmetric subproblems leads to elegant and efficient solutions. 🌿 #Day8 #DSA #LeetCode #Java #BinarySearchTree #Recursion #ProblemSolving #CodingJourney #LearnByDoing #Programming