LeetCode 1404: Number of Steps to Reduce Binary Number

🚀 Day 30/60 — LeetCode Discipline Problem Solved: 3Sum Closest Difficulty: Medium Today’s problem pushed beyond exact answers and focused on finding the closest possible sum to a given target — a subtle yet powerful variation of the classic 3Sum problem. By sorting the array and using a two-pointer approach, the solution efficiently explores combinations while continuously updating the closest result. This problem highlights how small modifications in logic can significantly change the nature of a problem — from exact matching to optimal approximation. 💡 Focus Areas: • Strengthened two-pointer technique • Practiced working with sorted arrays • Improved handling of optimization conditions • Learned to track and update closest values dynamically • Reinforced problem-solving under constraints ⚡ Performance Highlight: Achieved efficient runtime with optimized traversal. Not every problem asks for perfection — sometimes, the goal is to get as close as possible. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Java #Developers #Consistency #TechGrowth #LearnToCode

Today I finally understood the logic behind the Longest Substring Without Repeating Characters problem from LeetCode — and honestly, the journey of understanding it was more valuable than just getting the answer. At first, the idea of Sliding Window felt confusing. I couldn’t visualize how the substring keeps changing and how the algorithm still finds the correct result. So instead of jumping straight to the code, I broke it down step by step like a beginner: Example string: pwwkew I started tracking a window of characters: [p] [p,w] duplicate w → remove from front [w] [w,k] [w,k,e] duplicate w → remove until duplicate gone [k,e,w] The key insight that finally clicked for me: The window keeps changing, but a separate variable keeps track of the best result. currentLength = end - start + 1 maxLength = Math.max(maxLength, currentLength) So even though the window moves, the algorithm never loses the best answer it has seen so far. This problem helped me understand two important concepts: • Sliding Window technique • Maintaining a running best value (maxLength) Sometimes the real learning happens when you slow down and understand the logic instead of just memorizing the solution. Still learning, still exploring. 🚀 #DSA #Java #ProblemSolving #CodingJourney #SlidingWindow

🚀 Day 29/60 — LeetCode Discipline Problem Solved: Longest Common Prefix Difficulty: Easy Today’s problem focused on identifying the longest common starting pattern across multiple strings — a classic exercise in string comparison and iteration. The approach involved checking characters position by position across all strings until a mismatch is found. This reinforces how simple iterative logic can elegantly solve problems involving multiple inputs. It’s a reminder that sometimes, clarity in approach matters more than complexity in code. 💡 Focus Areas: • Strengthened string traversal techniques • Practiced comparing multiple inputs efficiently • Improved understanding of edge cases (empty strings, mismatch handling) • Reinforced early stopping conditions for optimization • Focused on clean and readable logic ⚡ Performance Highlight: Achieved efficient runtime with minimal overhead. Finding common ground across multiple inputs is not just a coding skill — it’s a pattern recognition mindset. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Strings #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Java #Developers #Consistency #TechGrowth #LearnToCode

Day 80 of DSA Problem Solving Solved LeetCode 876 — Middle of the Linked List 🔥 Today’s problem was all about linked list traversal and using the two-pointer technique efficiently. 🚀 Problem Idea We are given the head of a singly linked list, and the task is to return the middle node of the linked list. If there are two middle nodes, we return the second middle node. 💡 Key Learning The main insight was: If we use two pointers, one moving 1 step at a time and the other moving 2 steps at a time, then by the time the fast pointer reaches the end of the list, the slow pointer will be standing at the middle node. So instead of counting the total number of nodes first, we can directly find the middle in just one traversal. 🧠 Concepts Practiced Two Pointer Technique Linked List Traversal Fast and Slow Pointer Single Pass Traversal Pointer Movement Logic ⏱ Time Complexity Time: O(n) Space: O(1) 📈 Real Journey Behind the Solution At first, this problem looks very basic, and the brute force idea of counting nodes and then reaching the middle can come to mind quickly. But this question teaches a much smarter and cleaner approach using slow and fast pointers. This problem helped me strengthen my understanding of linked list fundamentals and pointer movement, which are extremely important in coding interviews. Every day, I’m realizing that even easy problems can teach very powerful concepts when solved with the right approach. #Day80 #DSA #LeetCode #Java #LinkedList #TwoPointers #CodingJourney #ProblemSolving #CodingDaily

Day 61 - LeetCode Journey Solved LeetCode 81: Search in Rotated Sorted Array II (Medium) today — a problem that combines binary search + edge case handling + duplicates. This isn’t just a normal binary search. Here, the array is rotated and may contain duplicates, which makes the decision logic more subtle. 💡 Core Idea: At every step, determine which half is sorted. Then decide whether the target lies in that sorted half. If duplicates block the decision, carefully shrink the search space. ⚡ Key Learning Points: • Applying binary search on a rotated array • Handling duplicate values that break clear ordering • Smart boundary adjustments (low++, high--) • Maintaining efficiency close to O(log n) in most cases The real challenge was not writing the code — It was thinking clearly about all possible scenarios. Problems like this strengthen pattern recognition and deepen understanding of search-based algorithms 💯 ✅ Stronger grip on modified binary search ✅ Better handling of tricky edge cases ✅ Improved logical decision-making Each variation of binary search builds sharper intuition. Still learning. Still improving. Still coding 🚀 #LeetCode #DSA #Java #BinarySearch #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Building a programming language was never on my roadmap. But somewhere between debugging tokens, parsing syntax, and fixing errors that didn’t make sense… I realized something. For the first time, errors weren’t my headache — they were meaningful. Every error told a story. Every fix made the system smarter. So I kept going. Right now, I’m working on something called THE Language — a simple, intuitive programming language built from scratch. Yes, I created a programming language 🤙. It has: • Its own lexer, parser, and interpreter • Custom syntax (not based on Python/JS) • A working VS Code extension (syntax + autocomplete) • A full documentation site Still refining things. Still breaking things. But it’s coming together. Launch soon 🚀 Sharing the brand image of the language with you guys, please drop your opinions over it in the comments. #buildinpublic #programming #developers #coding #100DaysOfCode #python #compiler #interpreter #lexer

Programming is also about choosing the right structure to solve a problem. Sometimes we try to solve everything with multiple conditions and checks. But in many cases, the solution is simply letting the process keep running and reacting to events as they happen. This kind of logic is very common in: • queue listeners • message consumers • automations • long-running services In the end, writing good software is often not about writing more code… It’s about choosing the right structure for the problem. #programming #coding #developer #softwareengineering #softwaredeveloper #python #backend #devlife #codinglife #tech #technology #webdevelopment #fullstack #developers #computerscience #automation #ai #machinelearning #programacao #tecnologia #desenvolvimento #desenvolvedores #engenhariadesoftware #backenddeveloper #fullstackdeveloper

🔥 𝗛𝗼𝘄 𝗜 𝗦𝘁𝗼𝗽𝗽𝗲𝗱 𝗕𝗿𝘂𝘁𝗲 𝗙𝗼𝗿𝗰𝗶𝗻𝗴 𝗡𝘂𝗺𝗯𝗲𝗿𝘀 𝗮𝗻𝗱 𝗦𝘁𝗮𝗿𝘁𝗲𝗱 𝗧𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗶𝗻 𝗗𝗶𝗴𝗶𝘁𝘀 Today’s problem looked simple: 𝗖𝗼𝘂𝗻𝘁 𝗵𝗼𝘄 𝗺𝗮𝗻𝘆 𝗻𝘂𝗺𝗯𝗲𝗿𝘀 𝗶𝗻 [𝗹𝗼𝘄, 𝗵𝗶𝗴𝗵] 𝗮𝗿𝗲 𝗕𝗮𝗹𝗮𝗻𝗰𝗲𝗱. A number is balanced if it has 𝗮𝘁 𝗹𝗲𝗮𝘀𝘁 𝘁𝘄𝗼 𝗱𝗶𝗴𝗶𝘁𝘀 and the 𝘀𝘂𝗺 𝗼𝗳 𝗱𝗶𝗴𝗶𝘁𝘀 𝗮𝘁 𝗼𝗱𝗱 𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻𝘀 𝗲𝗾𝘂𝗮𝗹𝘀 𝘁𝗵𝗲 𝘀𝘂𝗺 𝗮𝘁 𝗲𝘃𝗲𝗻 𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻𝘀. A brute force check over the range isn’t practical for large limits — this is where 𝗗𝗶𝗴𝗶𝘁 𝗗𝗣 comes in. 🧠 𝗧𝘂𝗿𝗻𝗶𝗻𝗴 𝗧𝘄𝗼 𝗦𝘂𝗺𝘀 𝗶𝗻𝘁𝗼 𝗢𝗻𝗲 𝗩𝗮𝗹𝘂𝗲 Instead of tracking two sums, I tracked: balance = (odd position sum) − (even position sum) If this balance becomes 0 at the end, the number is balanced. 🧩 𝗧𝗵𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗰 𝗥𝗮𝗻𝗴𝗲 𝗧𝗿𝗶𝗰𝗸 answer = solve(high) − solve(low − 1) Now the task reduces to counting balanced numbers from 0 to a given number. ⚙️ 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗡𝘂𝗺𝗯𝗲𝗿 𝗗𝗶𝗴𝗶𝘁 𝗯𝘆 𝗗𝗶𝗴𝗶𝘁 While forming the number left to right, I tracked: 1. digit index 2. current balance 3. whether we are under prefix restriction (tight) DP state: dp[idx][balance][tight] An OFFSET handles negative balances. 💡 𝗪𝗵𝗮𝘁 𝗧𝗵𝗶𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗧𝗮𝘂𝗴𝗵𝘁 𝗠𝗲 Converting conditions into a running state Thinking in terms of digit positions, not full numbers Understanding how the tight flag controls the search space Why Digit DP is powerful for large range constraints This problem helped me truly understand Digit DP by walking through the logic step by step. #DataStructures #Coding #Programming #Java #Recursion #Memoization #Tech #SoftwareEngineering #Developer #LearnInPublic #100DaysOfCode #CodeNewbie #CompetitiveCoding #CodeDaily #InterviewPrep #LeetCode #GeeksforGeeks #ComputerScience #ProblemSolvingSkills #CodingJourney

There’s an interesting divide emerging in software development. Many developers are having an identity crisis as they realise how powerful the new tools have become. Personally I’m enjoying software development more than ever for one reason… speed. Going from an idea to something that actually works in minutes or hours, instead of days or weeks. It reminds me of what first attracted me to Python: shipping something quickly instead of typing boilerplate for hours. Tools like Claude aren’t replacing the joy of building. If anything, they’re bringing it back. #DevLeadership #AIinSoftwareDevelopment #DeveloperProductivity

🚀 Daily LeetCode Challenge – Day 37 Today’s problem was Find All Possible Stable Binary Arrays I. Problem: We are given three integers zero, one, and limit. We need to count the number of stable binary arrays such that: The array contains exactly zero number of 0s. The array contains exactly one number of 1s. Any subarray with size greater than limit must contain both 0 and 1. In simpler terms, we cannot place more than limit consecutive 0s or 1s, otherwise the array becomes unstable. The brute force that came to mind: Generate all possible arrays using the given number of 0s and 1s and then check if they satisfy the limit condition. But this approach quickly becomes inefficient because the number of combinations grows rapidly. 💡 Better Idea – Dynamic Programming with Memoization First, we focus on the limit. The limit tells us the maximum number of identical elements that can appear consecutively. For example, if limit = 2, then sequences like [0,0,0] or [1,1,1] are not allowed because they contain more than two identical elements in a row, which would make the array unstable. To construct valid arrays, we add elements in blocks: ->If the last placed element was 1, the next block must contain 0s. ->If the last placed element was 0, the next block must contain 1s. ->The size of each block can range from 1 to min(remaining elements, limit). This ensures that: we never exceed the number of remaining 0s or 1s we never violate the limit constraint. We recursively explore all valid possibilities while keeping track of: ->remaining 0s ->remaining 1s ->the last placed element. To avoid recomputation, we store previously computed results in a DP table. ⚡ Time Complexity: O(zero × one × limit) ⚡ Space Complexity: O(zero × one) 🔍 Key Insight: Instead of generating all binary arrays, we construct them step by step while respecting the limit constraint and store intermediate results, which turns an exponential brute force solution into an efficient dynamic programming approach. #LeetCode #DailyCodingChallenge #Java #DynamicProgramming #Algorithms #ProblemSolving #CodingInterview