Min Cost String Conversion with Floyd-Warshall Algorithm

📘 LeetCode Daily — Balanced Binary Tree Checked tree balance by recursively comparing left and right subtree heights at every node. The solution worked, but it clearly showed how repeated height calculations increase time complexity—an important reminder that correct logic isn’t always optimal logic. Solid recursion practice and a good lead-in to optimization. #LeetCode #BinaryTree #Recursion #DSA #Java

Day: 43/365 📌 LeetCode POTD: Binary Number with Alternating Bits Easy Key takeaways/Learnings from this problem: 1. This one shows how clean bit tricks can replace messy string checks when working with binary patterns. 2. Big takeaway: sometimes a small observation (like using XOR or shifting) turns a pattern problem into a super neat one-liner. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

Solved one of the classic Binary Tree problems on LeetCode: Validate Binary Search Tree. At first glance, the problem seems straightforward just check if left <root< right. But the real challenge is ensuring that every node respects the global BST constraints, not just its immediate parent. Problems like this remind me how important it is to think beyond local conditions and consider global invariants in tree structures. #LeetCode #DataStructures #Java #BinaryTree #DSA #ProblemSolving #CodingJourney

🚀 Day 18 of #100DaysOfCode Solved Remove Duplicates from Sorted List II on LeetCode 🔗 🧠 Key insight: When duplicates appear in a sorted linked list, we need to remove all occurrences, not just one. Using a dummy (sentinel) node makes it easier to handle cases where duplicates start at the head. ⚙️ Approach: 🔹Create a dummy node pointing to the head 🔹Traverse the list with two pointers 🔹If a duplicate sequence is found, skip the entire block 🔹Otherwise, move forward normally ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney

Optimizing Sorting Logic Using Bit Manipulation (Java) Today I solved a problem that required sorting integers based on the number of set bits in their binary representation. Instead of using a direct sorting approach, I implemented a custom comparator with a PriorityQueue and used Brian Kernighan’s algorithm to count set bits efficiently: n = n & (n - 1) This reduces time complexity for counting bits to O(number of set bits). 📊 Result: • 77/77 test cases passed • Runtime: 7ms • Beat 78% of submissions Key takeaway: Optimization is not just about solving — it’s about choosing the right approach and reducing unnecessary operations. Bit manipulation continues to be one of the most powerful tools in algorithm design. #DSA #Java #BitManipulation #LeetCode #ProblemSolving #SoftwareEngineering

📘 LeetCode Daily — Balance a Binary Search Tree Solved this by first using inorder traversal to convert the BST into a sorted list, then reconstructing the tree from the middle element to ensure balance. This approach clearly showed how traversal order captures structure and how choosing the midpoint at each step naturally leads to a height-balanced tree. A neat example of combining traversal + divide-and-conquer. #LeetCode #BinarySearchTree #InorderTraversal #DivideAndConquer #DSA #Java

Day: 44/365 📌 LeetCode POTD: Count Binary Substrings Easy Key takeaways/Learnings from this problem: 1. The real trick is noticing you don’t need to check every substring — just track lengths of consecutive 0s and 1s. 2. Big takeaway: many string problems become simple once you focus on grouping patterns instead of brute force counting. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

Day 13/100 – LeetCode Challenge 🚀 Problem: Binary Search Approach: Maintained left and right pointers Compared middle element with target Reduced the search space by half each step Time Complexity: O(log n) Space Complexity: O(1) Key takeaway: Binary search is the foundation for solving problems with logarithmic efficiency. #LeetCode #100DaysOfCode #DSA #Java #ProblemSolving #InterviewPrep #100DaysOfLeetCode

Day: 40/365 📌 LeetCode POTD: Add Binary Easy Key takeaways/Learnings from this problem: 1. This one’s a reminder that binary addition is just normal addition with a carry you manage manually, nothing fancy. 2. Big takeaway: when strings represent numbers, think digit-by-digit from the end — clean logic > converting to integers. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷

🚀 Day 13 of #100DaysOfCode Solved Remove Linked List Elements on LeetCode 🔗 🧠 Key insight: While traversing a linked list, careful pointer updates are needed—especially when the head node itself matches the value to be removed. ⚙️ Approach: 🔹Handle cases where the head contains the target value 🔹Traverse the list using a pointer 🔹Skip nodes whose value matches the given target by adjusting next pointers ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #100DaysOfCode #LeetCode #DSA #LinkedList #Java #ProblemSolving #LearningInPublic #CodingJourney