Mastering Algorithms with JavaFX Sorting Visualizer

🚀 Day 13/100 — Recursive Deconstruction Today’s Challenge: LeetCode 761 - Special Binary String 🧩 Yesterday was about bits; today was about Structural Grammar. Special Binary Strings aren't just 1s and 0s; they are a language. The Realization: A special string is like a valid set of parentheses. 1 is ( and 0 is ). To find the "lexicographically largest" version, you have to break the string into its most basic components, sort them, and put them back together. My 0ms Optimization Strategy: 1. Mental Mapping: Treated the string as a nested structure. If 1...0 is a special string, I stripped the outer layer, solved the inside, and then re-wrapped it. 2. Greedy Reassembly: Used Collections.sort() with a reverse comparator. In binary, "larger" just means the 1s appear as early as possible. 3. Memory Management: Minimized object creation by identifying "split points" first before committing to substring allocations. Reflection: Sometimes the fastest way to solve a problem isn't to iterate forward, but to look at the problem as a recursive tree. Every "Special" chunk is a node that can be reordered to maximize the total value. 13 days down. The logic is getting deeper. 87 days to go. 🛠️ #Java #DSA #LeetCode #100DaysOfCode #Recursion #StringAlgorithms #SoftwareEngineer #CodingJourney #Optimization

AI tools are just the next level of abstraction. We abstracted away assembly with C. Java and C++ raised the level of abstraction. Frameworks added another layer of abstraction. We’ve been stacking layers for decades. Engineering still exists. Developers are still programming. AI is simply the next abstraction layer. What do you think?

Day 17 of DSA practice 🚀 (Deep Dive into Binary Search) Today I solved Problem #4 – Median of Two Sorted Arrays — and it was a really insightful one. Instead of merging the two sorted arrays (which would take O(n + m) time), I learned a smarter approach to find the median without actually creating the combined array. Key takeaways: 1) Using binary search on partitions instead of values 2) Dividing the arrays in a way that left partition ≤ right partition 3) Achieving O(log(min(n, m))) time complexity Beyond the algorithm, I also learned something important about code design: The importance of separation of concerns. Breaking the logic into clear responsibilities made the solution more readable, easier to debug, and conceptually simpler — even for a complex problem. Today wasn’t just about solving a hard problem, it was about improving how I think and structure solutions 🔥 #DSA #LeetCode #BinarySearch #Algorithms #ProblemSolving #CleanCode #Java #LearningInPublic #100DaysOfCode

Continued with Arrays today and worked on the Dutch Flag Algorithm to sort an array of 0s, 1s, and 2s in one pass. This problem was less about sorting and more about pointer management. int[] arr = {2, 0, 2, 1, 1, 0}; int low = 0, mid = 0, high = arr.length - 1; while (mid <= high) {   if (arr[mid] == 0) {     swap(arr, low, mid);     low++;     mid++;   } else if (arr[mid] == 1) {     mid++;   } else {     swap(arr, mid, high);     high--;   } } for (int x : arr) {   System.out.print(x + " "); } public static void swap(int[] arr, int i, int j) {   int temp = arr[i];   arr[i] = arr[j];   arr[j] = temp; } // Output: 0 0 1 1 2 2 What this problem highlighted for me: - multiple pointers can work together in a single loop - not every problem needs nested loops - pointer movement depends on what value is found - getting one pointer wrong breaks the entire logic This felt like my first real exposure to a one-pass array algorithm. Continuing with Arrays & ArrayLists today. #Java #DSA #Arrays #LearningInPublic #ProblemSolving #Coding #Programming #DeveloperJourney #JavaDeveloper

Remember that one semicolon that kept you awake all night. You debugged the logic, Restructured the code, and questioned my entire approach only to find it was a single missing character. Moments like these remind you: in tech, growth isn’t just about building big things. It’s about mastering the smallest details . . . #ai #ml #java

𝗗𝗮𝘆 𝟰𝟴/𝟭𝟬𝟬 | 𝗖𝗼𝗻𝘃𝗲𝗿𝘁 𝗕𝗶𝗻𝗮𝗿𝘆 𝗡𝘂𝗺𝗯𝗲𝗿 𝗶𝗻 𝗔 𝗟𝗶𝗻𝗸𝗲𝗱 𝗟𝗶𝘀𝘁 𝘁𝗼 𝗜𝗻𝘁𝗲𝗴𝗲𝗿 Day 48 ✅ — Binary logic meets linked list traversal. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 #𝟭𝟮𝟵𝟬: Convert Binary Number in a Linked List to Integer (Easy) From LeetCode 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: Each node represents a binary digit (0 or 1). The head is the most significant bit. So this isn’t just a linked list problem — it’s a 𝗯𝗶𝗻𝗮𝗿𝘆 𝘁𝗼 𝗱𝗲𝗰𝗶𝗺𝗮𝗹 𝗰𝗼𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻 problem wrapped inside linked list traversal. Two key steps: 1️⃣ Compute the length of the list 2️⃣ Traverse again and apply positional binary weights (2^(length-1)) If a node contains 1, add 2^(position) to the result. Classic bit-weight logic. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 👉 First pass: calculate linked list length 👉 Second pass: • If node value is 1 → add 2^(length-1) • Decrement length 👉 Handle last node separately Time Complexity: O(n) Space Complexity: O(1) Two traversals, constant space, clean logic. 𝗠𝘆 𝗥𝗲𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: This problem reinforces something important: Linked list questions aren’t always about pointer manipulation. Sometimes they test whether you can layer fundamental concepts (like binary math) on top of traversal mechanics. The more I practice, the clearer patterns become: Traversal is routine. The real thinking is in identifying the hidden concept. 𝗖𝗼𝗱𝗲:🔗 https://lnkd.in/g9TyHZGk 𝗗𝗮𝘆 𝟰𝟴/𝟭𝟬𝟬 ✅ | 𝟱𝟮 𝗺𝗼𝗿𝗲 𝘁𝗼 𝗴𝗼! #100DaysOfCode #LeetCode #LinkedList #Binary #DataStructures #CodingInterview #SoftwareEngineer #Java #Algorithms #TimeComplexity #Programming

Day 14 of Daily DSA 🚀 Solved LeetCode 153: Find Minimum in Rotated Sorted Array ✅ Approach: Used Binary Search to locate the minimum element in a rotated sorted array. At each step, compared nums[mid] with nums[end] to determine which half is unsorted and contains the minimum. By shrinking the search space intelligently, the minimum element is found efficiently. A great example of how Binary Search adapts to rotated arrays. ⏱ Complexity: • Time: O(log n) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.66 MB (Beats 87.66%) Binary Search mastery keeps leveling up 💪 #DSA #LeetCode #Java #BinarySearch #ProblemSolving #DailyCoding #Consistency

After understanding basic recursive flow, I moved to calculating power using recursion. The first version was straightforward — multiply a by itself b times. But that approach was linear. Then I implemented the logarithmic version. That’s where recursion started feeling powerful. What changed here: - Instead of reducing the problem by 1 step, I reduced it by half. - Learned that recursion can follow divide-and-conquer logic. - Understood how even/odd cases change the recurrence. - Saw how time complexity drops from O(n) to O(log n). Core logic : if (b == 0) return 1; long half = power(a, b / 2); if (b % 2 == 0)   return half * half; else   return a * half * half; This was the first time recursion felt like optimization, not just structure. It wasn’t about calling a function again. It was about reducing the problem smarter. #recursion #java #dsajourney #algorithms #problemSolving

When I first encountered the var keyword in Java, its promise of type inference felt like a shortcut to faster code, yet the rule that it applies only to local variables reminded me that shortcuts have boundaries, just as strategic decisions in business must respect structural constraints. That moment reinforced how my engineering background gives me a disciplined lens for evaluating what is possible within a given framework. Understanding why var cannot be used for class‑level fields sharpened my appreciation for clear scope definition, predictable memory management, and maintainable APIs, all of which translate into better architectural decisions across any technology stack. 1. Systems thinking: I treat variable scope as part of the larger architecture, ensuring that state is managed where it belongs. 2. Scalability awareness: Recognizing scope limits helps design components that can grow without unintended coupling. 3. Data driven decisions: I rely on compiler feedback and runtime metrics to validate the impact of type inference on performance. 4. Execution discipline: I follow language rules rigorously, which reduces bugs and accelerates delivery cycles. 5. Continuous learning: I stay current with language evolution, turning each restriction into an opportunity to refine best practices. I invite peers to share how language constraints have shaped their design philosophies and what strategies they employ to turn limits into leverage. My journey continues to be defined by turning technical rigor into strategic advantage as I lead future‑focused development initiatives. #Java #type inference #software architecture #career growth #continuous learning