Minimum Operations to Transform Binary String with Java Solution

Day 70 - LeetCode Journey Solved LeetCode 88: Merge Sorted Array (Easy) today — a classic problem that focuses on array manipulation and the two-pointer technique. The challenge is to merge two sorted arrays into one sorted array without using extra space, by modifying nums1 in-place. 💡 Core Idea: Instead of merging from the beginning, we start from the end of the arrays. Why? Because nums1 already has extra space at the end to accommodate elements from nums2. We use three pointers: • i → last valid element in nums1 • j → last element in nums2 • k → last position of merged array At each step, we place the larger element at position k, ensuring the array remains sorted. ⚡ Key Learning Points: • Using the two-pointer technique from the end • Performing in-place array merging • Maintaining O(m + n) time complexity • Avoiding unnecessary extra space This problem is a great reminder that sometimes changing the direction of traversal makes the solution much simpler. ✅ Better understanding of array manipulation ✅ Stronger grasp of two-pointer techniques ✅ Improved problem-solving efficiency Small problems like this build strong fundamentals for bigger challenges 🚀 #LeetCode #DSA #Java #TwoPointers #Arrays #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Day 21 of my LeetCode consistency journey 🚀 Today I solved the Daily Temperatures problem. The goal was to determine how many days we must wait to experience a warmer temperature for each day in the list. Instead of using a brute-force approach, I implemented an optimal O(n) solution using a Monotonic Stack. This technique efficiently tracks unresolved indices and updates them when a warmer temperature appears. Key takeaway: Using a stack-based approach helps reduce unnecessary comparisons and significantly improves performance compared to the naive O(n²) method. Consistency > intensity. Small progress every day compounds into real skill. #LeetCode #DataStructures #Algorithms #ProblemSolving #Java #CodingJourney #100DaysOfCode

🚀 Day 42 of My LeetCode Journey Today’s problem: Regular Expression Matching This wasn’t just another coding problem — it forced me to think in terms of state transitions and decision trees, not brute force. 🔍 Key Learning: - Pure recursion is not enough → leads to exponential time - Introduced Dynamic Programming (Top-Down with Memoization) - Learned how to break the problem into: - Matching current characters - Handling "*" (zero or more occurrences) 🧠 Core Insight: Instead of trying all possibilities blindly, cache results of subproblems → avoids recomputation. ⚡ Result: - Runtime: 1 ms (Beats 99.99%) - Efficient DP solution with optimal pruning 💡 Takeaway: Hard problems aren’t about syntax — they’re about modeling the problem correctly. #Day42 #LeetCode #DataStructures #DynamicProgramming #Java #CodingJourney

🚀 Day 525 of #750DaysOfCode 🚀 💡 LeetCode 1980: Find Unique Binary String Today’s problem was an interesting one involving binary strings and a clever observation. We are given n unique binary strings of length n, and the task is to return any binary string of length n that does not exist in the given array. 🔎 Approach I Used I applied a concept similar to Diagonalization. Traverse the array from 0 → n-1 Look at the i-th character of the i-th string Flip it (0 → 1 or 1 → 0) Append the flipped character to build a new string This guarantees the newly created string differs from every string in the list at least at one position, ensuring it is unique and not present in the array. ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(n) This approach works efficiently because the constraints are small and we only need to ensure one position difference with each string. Problems like this highlight how a simple observation can eliminate brute force completely. #leetcode #coding #programming #java #datastructures #algorithms #problemSolving #developer #codingchallenge #750DaysOfCode

🚀 Day 12 of My LeetCode Journey Today I solved Pow(x, n) (LeetCode 50). Problem: Implement a function to calculate x raised to the power n (xⁿ). The challenge is to handle large powers efficiently instead of multiplying x repeatedly. Approach: I used Binary Exponentiation (Fast Power). Key Idea: • If n is even → xⁿ = (xⁿ⁄²)² • If n is odd → xⁿ = x × xⁿ⁻¹ • If n is negative → convert to 1/x and make n positive This reduces the time complexity from O(n) to O(log n). Concepts Used: • Math • Binary Exponentiation • Iterative optimization Time Complexity: O(log n) Space Complexity: O(1) #leetcode #datastructures #algorithms #java #codinginterview #softwareengineering

🚀 Day 24/60 — LeetCode Discipline Problem Solved: Symmetric Tree (Revision) Difficulty: Easy Today’s practice focused on revisiting a classic binary tree problem — checking whether a tree is symmetric around its center. The key idea is to treat the left and right subtrees as mirror images and recursively compare their corresponding nodes. By verifying both structure and node values simultaneously, the algorithm determines whether the tree maintains perfect symmetry. Problems like this highlight how recursion naturally fits tree-based structures and helps simplify complex comparisons. 💡 Focus Areas: • Strengthened recursive tree traversal • Practiced mirror comparison of subtrees • Improved understanding of binary tree symmetry • Reinforced recursive problem-solving patterns • Focused on writing clean and structured logic ⚡ Performance Highlight: Achieved 0 ms runtime (100% performance) on submission. Consistent practice across arrays, strings, stacks, bit manipulation, and now tree structures continues to deepen my overall algorithmic intuition. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #BinaryTree #Recursion #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers #Java

𝗗𝗮𝘆 𝟲𝟵/𝟭𝟬𝟬 — 𝗥𝗲𝗺𝗼𝘃𝗲 𝗞 𝗗𝗶𝗴𝗶𝘁𝘀 Day 69. One day from 70. This problem broke my brain. Then it clicked. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟰𝟬𝟮: Remove K Digits (Medium) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Given a number as a string and k, remove k digits to make the smallest possible number. Example: "1432219", k=3 → "1219" Which 3 digits do you remove? And in what order? 𝗧𝗵𝗲 𝗜𝗻𝘀𝗶𝗴𝗵𝘁: Greedy + Monotonic Stack. Remove a digit if the next digit is smaller. Keep the stack increasing. This builds the smallest number left-to-right. Example: "1432219" See '4' then '3'? Remove '4' See '3' then '2'? Remove '3' See '2' then '2'? Keep both Result: "12219" → remove trailing '9' → "1219" 𝗠𝘆 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: StringBuilder as stack. For each digit: While stack top > current digit AND k > 0: pop and decrement k Append current digit After loop, remove remaining k digits from the end. Strip leading zeros. Time: O(n), Space: O(n) 𝗪𝗵𝘆 𝗜𝘁 𝗠𝗮𝘁𝘁𝗲𝗿𝘀: This combines greedy thinking with monotonic stack. Two patterns, one solution. Understanding when to be greedy and when to use a stack—that's the skill. 𝗖𝗼𝗱𝗲: https://lnkd.in/gv36YUfj 𝗗𝗮𝘆 𝟲𝟵/𝟭𝟬𝟬 ✅ 𝟲𝟵 𝗱𝗼𝘄𝗻. 𝟯𝟭 𝘁𝗼 𝗴𝗼. 𝗧𝗼𝗺𝗼𝗿𝗿𝗼𝘄 = 𝟳𝟬. #100DaysOfCode #LeetCode #MonotonicStack #GreedyAlgorithm #Algorithms #CodingInterview #Programming #Java #MediumLevel #PatternCombination #Day70Tomorrow

🚀 Day 23/60 — LeetCode Discipline Problem Solved: Remove Duplicates from Sorted Array (Revision) Difficulty: Easy Today’s practice focused on revisiting a classic array problem that leverages the two-pointer technique. Since the array is already sorted, duplicates naturally appear next to each other. The idea is to maintain one pointer for the position of the last unique element and another pointer to traverse the array, updating the array in-place whenever a new unique value appears. Problems like this beautifully demonstrate how understanding the structure of the data can simplify the solution significantly. 💡 Focus Areas: • Strengthened two-pointer array technique • Practiced in-place array modification • Reinforced understanding of sorted array properties • Improved clean and efficient iteration logic • Focused on writing simple and readable code ⚡ Performance Highlight: Achieved ~79% runtime efficiency on submission. Consistent practice with classic problems continues to refine core algorithmic patterns and strengthen problem-solving discipline. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers #Java

𝗗𝗮𝘆 𝟳𝟬/𝟭𝟬𝟬 — 𝟳𝟬% 𝗖𝗢𝗠𝗣𝗟𝗘𝗧𝗘 🎉 70 days. 70 problems. 70% done. 𝗜 𝗱𝗶𝗱𝗻'𝘁 𝗾𝘂𝗶𝘁. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟭𝟵𝟭𝟬: Remove All Occurrences of a Substring (Medium) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Remove all occurrences of a substring from a string. Keep removing until no more exist. Example: s = "daabcbaabcbc", part = "abc" → "dab" Stack behavior again. Build string character by character. Check the end for pattern matches. Remove when found. 𝗠𝘆 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: StringBuilder as stack. For each character: Append it Check if the last m characters match the pattern If yes, delete them Continue Time: O(n × m), Space: O(n) 𝗪𝗵𝗮𝘁 𝟳𝟬 𝗗𝗮𝘆𝘀 𝗧𝗮𝘂𝗴𝗵𝘁 𝗠𝗲: 𝗗𝗮𝘆 𝟭: Basic arrays felt hard 𝗗𝗮𝘆 𝟯𝟬: Started linked lists, struggled 𝗗𝗮𝘆 𝟱𝟬: Linked lists = second nature 𝗗𝗮𝘆 𝟲𝟬: Stacks, queues, patterns everywhere 𝗗𝗮𝘆 𝟳𝟬: Combining patterns feels natural The progression is real. The compound effect is real. 𝗧𝗵𝗲 𝗧𝗿𝘂𝘁𝗵: 70 days ago, I wasn't sure I could finish this. Some days I didn't want to code. Some days felt pointless. But I showed up anyway. 𝗧𝗵𝗮𝘁'𝘀 𝘁𝗵𝗲 𝘀𝗸𝗶𝗹𝗹 𝘁𝗵𝗮𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀—not talent, not motivation, but showing up when you don't feel like it. 𝗖𝗼𝗱𝗲: https://lnkd.in/gd-QRcxU 𝟳𝟬 𝗱𝗼𝘄𝗻. 𝟯𝟬 𝘁𝗼 𝗴𝗼. 70% complete. The finish line is close. Let's bring this home. 𝗗𝗮𝘆 𝟳𝟬/𝟭𝟬𝟬 ✅ #100DaysOfCode #LeetCode #70DayMilestone #Consistency #Stack #Algorithms #CodingChallenge #Programming #Java #NeverQuit #GrowthMindset #70Percent #AlmostThere