Optimized Permutations Backtracking in Java

Day 74 - LeetCode Journey Solved LeetCode 234: Palindrome Linked List (Easy) today — a problem that combines multiple concepts like two pointers + reversing a linked list. The goal is to check whether the linked list reads the same forward and backward. 💡 Core Idea: Instead of using extra space, we optimize by working directly on the list: Find the middle of the list using slow & fast pointers Reverse the second half of the list Compare both halves node by node If all values match → it’s a palindrome ✔️ ⚡ Key Learning Points: • Using slow & fast pointers to find the middle • Reversing half of the linked list efficiently • Comparing two linked list halves • Achieving O(n) time and O(1) space This problem is a perfect example of combining multiple patterns into one clean solution. It’s not just about solving — it’s about recognizing how previously learned concepts fit together 💯 ✅ Better understanding of linked list traversal ✅ Stronger grip on combining multiple techniques ✅ Improved optimization mindset (space efficiency) These are the kinds of problems that build real confidence in DSA 🚀 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Yesterday I had one of those debugging sessions that remind you why software engineering is both frustrating… and beautiful. I was dealing with a counting bug. No matter how many times I traced the loop, the count kept returning a number higher than the actual iterations I could clearly see in the program. It didn’t make sense. The architecture was a two-step dependency: A class Using a module That depended on another base module All three were written by me for different use cases. So naturally, I kept searching in the “obvious” place: the current file. Nothing. After going in circles for a while, something nudged me: “Check the dependency modules.” And there it was. The base module was incrementing a counter inside the __setitem__ magic method. That subtle behavior tucked away in a lower-level dependency was silently affecting the final count. And that was the bug. It’s funny how the real issue wasn’t in my immediate environment at all. Lesson reinforced: 👉 Sometimes the problem isn’t where the error shows up. 👉 It’s in what your system depends on. 👉 Abstractions don’t remove complexity, they relocate it. As engineers, we don’t just debug code. We debug relationships between pieces of code. And sometimes, the fix is simply remembering to zoom out. Back to building. #SoftwareEngineering #Debugging #Python #ProblemSolving #BackendDevelopment

Day 59 - LeetCode Journey Solved LeetCode 41: First Missing Positive (Hard) today — a problem that truly tests deep understanding of arrays, indexing, and optimization. This isn’t just about coding, it’s about thinking in-place, minimizing space, and using constraints smartly. 💡 Core Idea: Instead of using extra space, we treat the array itself as a hash map and place each element at its correct index (value → index mapping). This transforms the problem into finding the first index where the expected value is missing. ⚡ Approach Highlights: • Cyclic placement of elements to their correct positions • Ignoring invalid values (≤ 0 or > n) • Swapping until every valid number is at its right index • Final scan to find the first missing positive 🚀 Why this is powerful: • Achieves O(n) time complexity • Uses O(1) extra space • Demonstrates in-place hashing technique • Strengthens understanding of index manipulation patterns These are the kinds of problems that build real interview-level thinking — not just solving, but optimizing 💯 Every hard problem pushes boundaries a little further. Slow progress is still progress. ✅ Improved understanding of in-place algorithms ✅ Better optimization mindset ✅ Stronger grip on edge cases Still learning. Still improving. Still coding 🚀 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #Algorithms #DataStructures #Arrays #Optimization #InterviewPreparation #KeepCoding #GrowthMindset

Day 41 :- Exploring Contribution Logic: Sum of Subarray Minimums ✅ Today’s DSA session focused on a unique "Divide and Conquer" approach to a classic monotonic stack problem. I tackled 907. Sum of Subarray Minimums by shifting the focus from individual subarrays to the contribution of each element to the final sum. The Technical Breakdown: Contribution Technique: Instead of generating every possible subarray, I calculated how many subarrays have a specific element arr[minIdx] as their minimum. This is determined by the formula (minIdx - left + 1) * (right - minIdx + 1). Recursive Partitioning: By finding the global minimum in the current range [left, right], I calculated its total contribution and then recursively split the array into two halves: those to the left of the minimum and those to the right. Handling Duplicates: I used a strict "less than" check (arr[i] < arr[minIdx]) to consistently pick the first occurrence of a duplicate. This prevents double-counting subarrays when identical values are present. The Complexity Trade-off: While this recursive approach is highly intuitive and uses the Divide and Conquer paradigm, it can reach O(n^2) in the worst case (like a sorted array). This serves as a perfect conceptual bridge before moving toward the O(n) Monotonic Stack optimization! It's a great exercise in changing your perspective from "finding all subarrays" to "calculating the impact of each element"! 🚀 A huge thanks to my mentor, Anchal Sharma and Ikshit .. for the incredible support and for helping me stay consistent on this journey. Having that accountability makes all the difference! #DSA #Java #100DaysOfCode #DivideAndConquer #Recursion #ProblemSolving #Mentorship #LeetCode #SoftwareEngineering

Day 36 :- Binary Search & Range Finding: Find First and Last Position of Element ✅ Today’s DSA session was a great exercise in extending the classic Binary Search to handle multiple occurrences of a target value. I tackled LeetCode 34. Find First and Last Position of Element in Sorted Array, focusing on how to efficiently pinpoint a range within a sorted dataset. The Technical Breakdown: Hybrid Search Strategy: I started with a standard Binary Search to find any instance of the target. This immediately gives us an O(log n) starting point. Linear Expansion: Once the target was found, I used two pointers to expand outward from the meeting point. This identifies the exact boundaries where the target values start and end. Edge Case Handling: The logic naturally handles cases where the target isn't present by returning [-1, -1], and it manages single-element arrays or cases where the target spans the entire array. The Trade-off: While this approach is very intuitive, it can reach O(n) in the worst case (e.g., an array of all identical numbers). It’s a great stepping stone before diving into the pure O(log n) approach of finding the "leftmost" and "rightmost" indices independently! It's a solid reminder that Binary Search isn't just for finding a single value—it's the foundation for navigating any sorted range! 🚀 A huge thanks to my mentor, Anchal Sharma and Ikshit .. for the incredible support and for helping me stay consistent on this journey. Having that accountability makes all the difference! #DSA #Java #100DaysOfCode #BinarySearch #TwoPointers #ProblemSolving #Mentorship #LeetCode #SoftwareEngineering

I recommend often to favor composition/delegation over inheritance when inheritance is being abused just for code reuse without following the Liskov Substitution Principle. That said, I have observed cases in which devs over-employ composition over inheritance when in fact inheritance would provide the most readable and understandable code that is closest to the business domain model. Balance is important in Software Engineering! Balance is a lost art in our industry. People nowadays either go 100% FP with languages like Elixir without appreciating the benefits of OOP when they yield more productive/maintainable code, or go full Composition via languages that don't support inheritance like Clojure without appreciating the benefits of Inheritance when it better maps to real world concepts, or go full Static Typing without appreciating Dynamic Typing when it yields much simpler code, or even go full over-engineering without appreciating just-enough engineering when it is good enough. Going all the way in one direction only is often a symptom of laziness or lack of skill by devs who are unwilling to think carefully, learn both sides of a spectrum of practices, or make an effort in choosing the right balance of Software Engineering practices for each specific situation they encounter. Practicing balance is the difference between expert Software Engineers and average Software Engineers! #softwareengineering #balance #softwareengineer #softwareengineers #programming #ruby #rails #rubyonrails #softwaredevelopment #oop #ood #inheritance #composition #delegation #objectorientedprogramming #objectorienteddesign #fp #functionalprogramming #statictyping #dynamictyping #overengineering #justenoughengineering

In today’s fast‑paced software world, clarity and collaboration are everything. That is where Spec‑Kit comes in, a framework designed to help teams move seamlessly from specifications to scaffolding and eventually into production‑ready code. Unlike traditional approaches where specs often sit untouched in documentation, Spec‑Kit makes them actionable. By starting with a simple .md file, developers can scaffold projects, check environments, and evolve ideas directly inside VS Code with the help of GitHub Copilot. The result is a more efficient workflow, where specs transform from simple notes into the structural core of software. #SpecKit #GitHubCopilot #VSCode #SoftwareDevelopment #OpenSource #DeveloperTools #Productivity #Innovation #CodingWorkflow #Java #Python #Go #TechLeadership #EngineeringExcellence

🚀 Today’s LeetCode Problem — Sort Integers by Number of 1 Bits Let’s solve today’s LC in story mode 🎭 Imagine numbers are contestants in a Binary Costume Contest. Today’s contestants: 👉 [5, 3, 7] But this contest has a twist 👇 👨⚖️ The judge doesn’t care about the number itself first. He cares about… 🎈 How many 1s are in their binary costume 🎭 What Are They Wearing? 🔹 5 → 101 → 🎈🎈 (2 ones) 🔹 3 → 011 → 🎈🎈 (2 ones) 🔹 7 → 111 → 🎈🎈🎈 (3 ones) 🏆 Judge’s Rules 1️⃣ Fewer 1s → Higher priority 2️⃣ Same number of 1s → Smaller number wins 👉 Step 1: 3 & 5 → 2 ones 7 → 3 ones So 7 goes last. 👉 Step 2: Tie between 3 and 5 Smaller number first → 3 before 5 ✅ Final Answer: [3, 5, 7] 💡 How I Solved It I implemented this using: 🔹 Brian Kernighan’s Algorithm for efficient bit counting 🔹 TreeMap to maintain sorted order by bit count + value 🔹 Also compared with built-in bitCount() + custom comparator sorting This ensures: ✔ Efficient bit counting ✔ Clean tie-breaking ✔ Optimal sorting logic If you’re interested, I’ve pushed the complete solution (Kernighan + TreeMap + built-in approach) : https://lnkd.in/gV9HZ9w4 👨💻 Would love feedback from fellow developers 🙌 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #100DaysOfCode #Tech #SoftwareEngineering

Refactoring a 50-line if-else block into a clean, scalable design can instantly change how a codebase feels to work with. Before refactoring, the signs are easy to spot: • Logic that’s hard to follow • Code that breaks easily and resists testing • Growing maintenance effort • Every new condition adds more risk than value After refactoring, clarity replaces chaos: • Strategy patterns or map based lookups in JavaScript, Python, and beyond • Improved structure and readability • New conditions added in a few lines, not dozens • Unit tests that are simpler, faster, and more reliable This kind of improvement highlights an often overlooked truth in software development: Code is read far more often than it is written. Clean architecture and thoughtful design patterns do more than tidy up code.  They reduce bugs, improve collaboration across teams, and make systems easier to evolve as requirements change.  Over time, these small refactoring decisions compound into software that’s more scalable, resilient, and enjoyable to maintain. At TopSkyll, we encourage developers to think beyond making it work and focus on building code that lasts. Developer discussion: Which refactoring technique or design pattern has helped you the most when working with legacy code? #CleanCode #Refactoring #SoftwareArchitecture #DesignPatterns #CodeQuality #DeveloperExperience #Programming #Engineering #TopSkyll