Solved LeetCode 283: Move Zeroes with two-pointer technique

🚀 LeetCode POTD — 3228. Maximum Number of Operations to Move Ones to the End 🎯 Difficulty: Medium | Topics: Greedy, String Manipulation, Two-Pointer Logic 🔗 Solution Link: https://lnkd.in/gAAxvfFV Today’s #LeetCode Problem of the Day was an interesting greedy + two-pointer problem. We’re given a binary string, and the task is to repeatedly move '1' over blocks of '0' until it reaches either another '1' or the end — and count the maximum operations possible. 🧠 My Approach: The key observation is that every '0' segment contributes operations equal to the number of '1's seen before it. I used a two-pointer technique: l → counts how many '1's we’ve encountered so far r → scans the string Whenever we encounter a '0' block, we add l to the result Every time we see a '1', we increment l This handles all possible valid moves optimally without actually simulating the operations. 💡 Core Idea: 👉 Each '1' can “jump” over every '0' segment that appears after it — the count of such jumps is the total number of operations. 📈 Complexity: Time: O(n) Space: O(1) 💬 Takeaway: Greedy algorithms often work beautifully when you track just the right variables. This problem shows how understanding movement relationships in a sequence can simplify what looks like a complicated operation. #LeetCode #ProblemOfTheDay #StringManipulation #GreedyAlgorithms #TwoPointers #DSA #CodingChallenge #SoftwareEngineering #CodingJourney #TechCommunity #100DaysOfCode

I recently tackled LeetCode 2654 – Minimum Number of Operations to Make All Array Elements Equal to 1. Most solutions simulate every operation. The approach that worked for me came from stepping back and thinking mathematically: 1️⃣ If there’s already a 1 in the array, it can be spread to all other elements efficiently. 2️⃣ If no 1 exists, find the shortest subarray whose GCD is 1 – creating a 1 from that subarray is the minimal first step. 3️⃣ Once a 1 exists, the rest follows in a straightforward way. It’s a reminder that sometimes understanding the structure of a problem beats brute-force coding. And here’s a little validation: ✅ Runtime: 1ms, beats 100% of submissions ✅ Memory: 56.1MB, beats 100% of submissions For anyone doing coding challenges or preparing for interviews, focus on insights like these – they often save more time than writing extra lines of code. #ProblemSolving #Algorithms #CodingMindset #LeetCode #SoftwareEngineering

🌟 Day 93 of My LeetCode Journey — Problem 686: Repeated String Match 💡 Problem Insight: Today’s problem explored how many times string A must be repeated so that string B becomes a substring of it. It’s a fun mix of string repetition and pattern matching — testing both logic and edge-case awareness. 🧠 Concept Highlight: The core idea is to keep repeating A until it’s at least as long as B, then check if B exists within it (or one more repetition). This problem reinforces concepts of string concatenation, searching, and boundary conditions in text processing. 💪 Key Takeaway: Sometimes, solutions aren’t about complexity but about knowing when to stop repeating — in both coding and persistence! ✨ Daily Reflection: Simple problems like these highlight the beauty of algorithmic reasoning — transforming trial-and-error into structured logic. #Day93 #LeetCode #100DaysOfCode #StringMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Persistence

🚀 LeetCode Daily Challenge Complete! Just solved "Final Value of Variable After Performing Operations" - a simple yet elegant problem that teaches the value of finding shortcuts in pattern matching! 💡 Solution Approach: ✅ Iterate through all operation strings ✅ Check middle character (index 1) ✅ If '-': decrement, if '+': increment ✅ Return final value The key insight: Instead of comparing full strings ("--X", "X--", "++X", "X++"), we can observe that ALL operations have the operator in the middle position! By checking just op[1], we instantly know whether to increment or decrement. Pattern recognition: "--X" and "X--" both have '-' at index 1 → decrement "++X" and "X++" both have '+' at index 1 → increment This single-character check is more efficient than string comparisons! Time Complexity: O(n) | Space Complexity: O(1) #LeetCode #StringParsing #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #CleanCode #PatternRecognition

🧩 LeetCode Challenge – Day 72 ✅ Dived into a string decoding problem today — a perfect blend of stacks, recursion, and pattern tracking. 🔗 LeetCode 394 – Decode String This challenge revolves around decoding expressions like 3[a2[c]], requiring careful handling of nested patterns and character reconstruction. It’s a great exercise in managing multiple layers of logic — keeping track of counts, substrings, and the overall decoded output step by step. 💡 Key Takeaways: • Stack-based parsing builds precision in handling nested structures. • Breaking problems into layers simplifies even the most complex logic. • Attention to detail is everything — one misplaced index can change the entire output. #Day72 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Stack #Strings #Parsing #Recursion

🚀 Day 37 of #100DaysOfCode Challenge 🚀 🧠 Problem: 🧩 LeetCode 282 — Expression Add Operators (Hard) This problem was all about exploring backtracking with arithmetic logic. We’re given a string of digits and need to insert +, -, or * between them to reach a target value. ⚙️ Approach Used backtracking to: -Pick every possible substring as the next number. -Try adding each operator before it (+, -, *). -Track three things: -current value → total so far -previous operand → to handle multiplication correctly -expression → the string we’re building -Also skipped invalid paths like numbers with leading zeros. 📘 Learning -Understood how to evaluate expressions on the fly without using eval(). -Learned to manage operator precedence (* before +/-) using recursion and previous operand adjustment. -Realized that some problems can’t be optimized further — they test how well you can prune and organize recursion. #100DaysOfCode #DSA #CodingChallenge #StriversSheet #ProblemSolving #TakeUForward  #Recursion #CodingInterview #ProgrammingTips #LeetCode  #Backtracking 

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🧩 LeetCode Challenge – Day 69 ✅ Explored another elegant twist in the world of recursion — generating unique subsets with duplicates in play. 🔗 LeetCode 90 – Subsets II This problem extends the classic subsets question by introducing duplicates, which means managing uniqueness through careful control. It’s a precise exercise in sorting, skipping, and structuring recursion to avoid redundancy — a true test of clean logical flow. 💡 Key Takeaways: • Sorting simplifies complexity — order enables control. • Handling duplicates trains precision and discipline in recursive solutions. • Elegant logic > brute force — small refinements can make solutions scalable and readable. #Day69 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Backtracking #Recursion #Subsets

🚀 Day 103 of My LeetCode Journey — Problem 61: Rotate List 💡 Problem Insight: Today’s problem was about rotating a linked list to the right by k places. That means shifting each node forward while the last node loops back to the head — a great test of both logic and pointer control. 🧠 Concept Highlight: The trick lies in: Connecting the list into a cycle (by linking the tail to the head). Finding the new head after length - (k % length) steps. Breaking the cycle to finalize the rotated list. This problem reinforces key ideas about circular linked lists, modular arithmetic, and efficient traversal. 💪 Key Takeaway: Rotation teaches that sometimes progress isn’t linear — moving in circles helps you find new beginnings in unexpected ways. ✨ Daily Reflection: Every linked list problem continues to refine my understanding of structure and precision — the true backbone of algorithmic thinking. #Day103 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #RotateList #TwoPointerTechnique #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

Day 22 of #100DaysOfCode Today I solved the “Permutation in String” problem on LeetCode — a tricky one that really sharpens your understanding of sliding window and frequency mapping in strings. 🧩 Problem in short: Given two strings s1 and s2, the task is to check if any permutation of s1 exists as a substring in s2. At first glance, it feels like a brute-force problem — generate all permutations of s1 and check each in s2. But that’s computational suicide for longer strings. So the challenge was to find a smarter, optimized approach. ⚙️ Intuitive Approach: Instead of generating permutations, I focused on character frequencies. Maintain two frequency arrays — one for s1 and one for the current window of s2. Slide the window across s2, adding and removing characters as you move. Whenever both frequency arrays match, it means that substring of s2 is a permutation of s1. This approach reduces the complexity drastically and relies on pattern recognition through frequency matching, not brute force. Every day in this challenge is a reminder that optimization isn’t about doing less work — it’s about doing the right work. #LeetCode #C++ #ProblemSolving #DSA #CodingJourney #100DaysOfCode