Solved LeetCode Problem 686: Repeated String Match

🚀 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

🚀 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

🎯 Day 83 of #100DaysOfCode 🔹 Problem: Count the Digits That Divide a Number – LeetCode ✨ Approach: A simple yet elegant digit-based problem! I extracted each digit of the number using modulo and division, then checked whether the digit cleanly divides the original number. Every valid digit increases the count — a perfect use-case for number breakdown and modular arithmetic. 🔢⚡ 📊 Complexity Analysis: ⏱ Time Complexity: O(d) — where d is the number of digits 💾 Space Complexity: O(1) — no extra data structures used ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.29 MB 🔑 Key Insight: Even basic problems sharpen precision — breaking numbers digit-by-digit reinforces strong logical thinking and clean coding habits. Sometimes the simplest loops teach the most. ✨ #LeetCode #100DaysOfCode #DSA #NumberTheory #ModularArithmetic #CleanCode #EfficientCoding #LogicBuilding #TechJourney #ProgrammingChallenge #CodingDaily

🚀 Daily DSA Challenge: Minimum Cost to Connect Ropes 🧩 Today I solved a classic greedy algorithm problem that’s both elegant and practical — connecting ropes with minimum total cost. 🔹 Problem Statement: We’re given an array of rope lengths. The goal is to connect all ropes into one single rope with the minimum total cost. The cost of connecting two ropes is the sum of their lengths. 🔹 Key Insight: At each step, connecting the two smallest ropes first always leads to the minimum total cost. This is a perfect use case for a greedy algorithm combined with a min-heap (priority queue) to efficiently pick the smallest ropes. 🔹 Why It Works: Each connection increases the total cost, so we must minimize large additions early on. By always merging the two smallest ropes, we ensure the incremental costs stay as low as possible — resulting in an overall minimum. 🔹 Complexity: Time Complexity: O(n log n) Space Complexity: O(n) 🔹 Real-world Analogy: Imagine combining different lengths of wire or cable — the cost to connect them grows as they get longer, so you’d always want to start small first! 💬 My Takeaway: This problem is a great reminder that sometimes the greedy choice at each step leads to the optimal overall solution — and that data structures like heaps can make such strategies efficient in practice. #DSA #CodingChallenge #Java #GreedyAlgorithm #ProblemSolving #DataStructures #Algorithms #LearningEveryday

🚀LeetCode Daily Challenge 🧩 Problem: Smallest Number With All Set Bits Problem Intuition: Given an integer n, your task is to find the smallest number that has the same number of bits as n when represented in binary, but with all bits set to 1. In simple terms — if n requires k bits to represent, you must find the smallest integer whose binary form has exactly k ones (111...1). 💡Example Insight: Let’s say n = 6 → Binary: 110 → requires 3 bits. The smallest number with all 3 bits set to 1 is 111 → which is 7 in decimal. Hence, the answer is 7. 🧠 Approach & Strategy: ✔ First, determine the number of bits needed to represent n: res = floor(log2(n)) + 1. ✔ Then, iterate from n to an upper limit and check for the first number having exactly res set bits. ✔ The check is performed using the built-in function __builtin_popcount(x) which counts the number of 1’s in the binary representation. ✔ Return the first number satisfying this condition. ⚙️ Complexity Analysis: Time Complexity: O(k) → Iterates until the matching number is found (within small bounds). Space Complexity: O(1) → Uses only integer variables. 🔗Problem: https://lnkd.in/dwR7Gp8i 💻 Solution: https://lnkd.in/dJU6Wrra #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

🔥 Day 222 - Daily DSA Challenge! 🔥 Problem: 🌳 Flatten Binary Tree to Linked List Given the root of a binary tree, flatten it into a linked list in-place, following the preorder traversal order (root → left → right). 💡 Key Insights: 🔹 The goal is to modify the tree without using extra space. 🔹 For each node, if a left subtree exists: 1️⃣ Find the rightmost node of the left subtree. 2️⃣ Connect that node’s right pointer to the current node’s right subtree. 3️⃣ Move the left subtree to the right and set left = null. 🔹 Repeat this process while traversing through the tree. ⚡ Optimized Plan: ✅ Traverse using a pointer (curr). ✅ If curr.left exists, attach it in place of curr.right and re-link the subtrees. ✅ Continue the process until the end of the tree. ✅ Time Complexity: O(n) — each node visited once. ✅ Space Complexity: O(1) — in-place transformation. 💬 Challenge for you: 1️⃣ Can you flatten the tree using recursion instead of iteration? 2️⃣ How would you modify this to produce a postorder or inorder flattened list? #DSA #BinaryTree #LinkedList #LeetCode #ProblemSolving #CodingChallenge #KeepCoding #100DaysOfCode

LeetCode 217: Contains duplicate ⁇ Suppose you have a list of numbers, and you want to know if any number appears more than once. It’s like making sure everyone in class has a unique roll number! Approach 1: Set - Go through each number. - If it’s not in your set, add it. - If you ever see a number already in your set, you’ve got a duplicate! Approach 2: Hash Table (Counter) - Use a Counter to count how often each number appears in the list. - If any number appears more than once, return True (there’s a duplicate). Complexity: - Time Complexity: O(n) — One pass through all numbers. - Space Complexity: O(n) — Storing seen numbers or counts. Both approaches are fast and effective for catching duplicates quickly! Let’s check our numbers and make sure everyone’s unique! Check out the problem here: https://lnkd.in/g-JgRTEn Keep going, keep revising, and keep building confidence! 💪🔥 #DSA #Coding #ProblemSolving #Learning

#Day67 of my LeetCode Journey 🚀   Starting with Recursion problems !  🧩 Question #8 – String to Integer (atoi) (Medium)  Brute Force Approach:   1) Convert the string manually step-by-step remove whitespaces, handle signs, read digits, and clamp values.   2) Check for invalid inputs and handle edge cases like overflow/underflow explicitly.   3) Use iterative parsing to process characters sequentially.   - Time Complexity: O(N)   - Space Complexity: O(1)  Optimal (Recursive) Approach:   1) Use recursion to simplify the parsing process each helper function handles one part (like skipping spaces, checking sign, removing zeros, or reading digits).   2) Extract digits recursively until a non-numeric character appears.   3) Convert digits to an integer and clamp it within the 32-bit signed range.   - Time Complexity: O(N)   - Space Complexity: O(N) (due to recursive calls)  ✨ That’s it for Day 67. The journey continues — see you on Day 68. Happy coding! 🚀 #Day67 #LeetCodeJourney #LeetCode #Recursion #String #Atoi #Python #DSA #CodingPrep

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