Solved LeetCode 2654 with a mathematical approach, beating 100% in runtime and memory.

Just solved LeetCode 283: Move Zeroes! Problem: Given an integer array nums, move all 0’s to the end while keeping the relative order of non-zero elements (in-place). leetcode.com +1 Approach: Used a two-pointer technique — one pointer tracks the position to place the next non-zero, the other scans the array. When we find a non-zero, swap it into the “next non-zero” position. Then fill the trailing positions with 0. AlgoMonster +1 Complexity: O(n) time, O(1) extra space. Takeaway: Even simple problems become elegant once you apply the right pattern (here: two-pointer in-place). https://lnkd.in/gJif99sG #coding #leetcode #interviewprep #arrays

🚀 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 

🚀 Just tackled an interesting string manipulation problem on LeetCode! 🚀 The challenge was to remove all digits from a string by repeatedly applying a specific operation: Find a digit. Delete that digit AND the closest non-digit character to its left. At first glance, it seems tricky to track which character to remove, but the solution becomes elegant with the right data structure. 💡 The Key Insight: This is a perfect use case for a stack! By processing the string from left to right, we can push non-digit characters onto the stack. Whenever we encounter a digit, we simply pop the top of the stack (the closest non-digit to the left). This efficiently handles the "deletion" in constant time. This problem is a great reminder of how choosing the right data structure can simplify complex-seeming tasks. The stack naturally models the "last-in, first-out" behavior we need for the deletion operation. #Coding #Algorithm #DataStructures #ProblemSolving #SoftwareEngineering #Tech #Programming #Developer

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency

💡 Day 78 of #100DaysOfCode 💡 🔹 Problem: Find Closest Number to Zero – LeetCode ✨ Approach: Traversed through the array while keeping track of the number closest to zero using absolute difference comparison. Handled ties by preferring the positive number — because even in code, positivity wins 😉 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — no extra space used ✅ Runtime: 3 ms (Beats 44.80%) ✅ Memory: 46.87 MB 🔑 Key Insight: Even the smallest differences matter — especially when you’re finding what’s closest to zero! ⚡ #LeetCode #100DaysOfCode #DSA #ProblemSolving #CodingChallenge #JavaProgramming #AlgorithmDesign #CodeJourney #StayPositive

Day 45 of LeetCode grind — “Make Array Elements Equal to Zero” (Problem #3354) This one looked like a simulation problem at first glance, but it’s actually an elegant math trick hiding under a messy description. Instead of simulating all that left-right bouncing chaos, you just compare prefix sums — figuring out where the array can be “balanced” around a zero. Key takeaway: Sometimes the shortest code comes from refusing to believe the problem is as complicated as it sounds. ✅ Accepted 🧠 Concepts: Prefix Sum, Balance Points 💬 Lesson: Elegant logic > brute force chaos Slowly crawling my way through 100 days of consistency — still standing, still debugging. #LeetCode #100DaysOfCode #ProblemSolving #Cplusplus #CodingJourney

🚀 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 7 of #120DaysOfCode Challenge 💡 Problem: Reverse Integer (LeetCode #7 | Medium) 📄 Problem Statement: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes it to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], then return 0. 🧩 My Approach: Extract the last digit of x using % 10. Build the reversed number step by step using rev = rev * 10 + digit. Carefully check for overflow before multiplying or adding — using INT_MAX and INT_MIN limits to ensure the reversed number stays valid. If overflow is detected, return 0. 🔍 Key Learnings: How to handle integer overflow without using 64-bit variables. Importance of edge case testing and boundary conditions. Reinforced understanding of modulus (%) and integer division (/) operations. 🔥 Progress: Day 7 / 120 📚 Language: C 🏁 Problem Solved: Reverse Integer (LeetCode #7) Every problem is a small step toward stronger logic and cleaner code! 💪 #100DaysOfCode #120DaysOfCode #CodingChallenge #LeetCode #CProgramming #ProblemSolving #LearnEveryday #BuildInPublic