LeetCode Challenge Day 58: TreeSet and State Tracking

🚀 Day 27/60 — LeetCode Discipline Problem Solved: Length of Last Word Difficulty: Easy Today’s problem looked simple, yet it emphasized a subtle but important skill — handling edge cases cleanly. The goal was to find the length of the last word in a string, ignoring any trailing spaces. Instead of splitting the string or using extra space, the solution efficiently traverses from the end, skipping unnecessary characters and counting only what truly matters. It’s a reminder that strong coding is not always about complexity — sometimes, it’s about precision and clarity in small details. 💡 Focus Areas: • Practiced string traversal from end • Improved handling of trailing spaces • Reinforced clean and efficient logic • Avoided unnecessary extra space usage • Strengthened edge-case thinking ⚡ Performance Highlight: Achieved 0 ms runtime (100% performance). Small problems, when approached with discipline, sharpen the instincts that solve big ones. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Strings #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #Java #Developers #Consistency #TechJourney #LearnToCode

🚀 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 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

Last week, I solved several coding problems using Stacks. At first, it felt like just another data structure. But something interesting happened. The more problems I solved, the more I realized how many real problems actually use stacks behind the scenes. For example: • Valid Parentheses • Remove Adjacent Duplicates • Remove Outer Parentheses • Decode String like 3[a2[c]] • Longest Valid Parentheses • Simplifying a File Path At first glance, these problems look completely different. But once you see the pattern, the solution becomes clearer: 👉 Push when something opens 👉 Pop when something closes 👉 Use the last element to validate or build the result That’s the beauty of problem solving in programming. Different problems. Different stories. But sometimes the same simple idea solves them all. This week reminded me of an important lesson: Mastering fundamentals like Stacks, Queues, and HashMaps makes complex problems much easier. Because good developers don’t just memorize solutions, They recognize patterns. #DataStructures #Algorithms #Java #CodingJourney #ProblemSolving #Developers

Day 80 - LeetCode Journey 🚀 Solved LeetCode 876: Middle of the Linked List (Easy) — a classic problem that introduces one of the most powerful patterns in linked lists. At first, finding the middle seems straightforward. But doing it efficiently in a single pass is where the real insight comes in. 💡 Core Idea (Slow & Fast Pointer Technique): Initialize two pointers: slow and fast Move slow by 1 step and fast by 2 steps When fast reaches the end, slow will be at the middle If there are two middle nodes, this approach naturally returns the second one. 🤯 Why it works? Because the fast pointer covers double the distance of the slow pointer, so when it finishes traversing the list, the slow pointer is exactly halfway. ⚡ Key Learning Points: • Efficient single-pass traversal • Mastering the slow-fast pointer pattern • Handling even and odd length lists • Achieving O(n) time and O(1) space • Building intuition for pointer-based problems This is a foundational pattern used in many advanced problems. Also, this pattern connects with: Linked List Cycle detection Palindrome Linked List Reorder List Finding intersection of two linked lists ✅ Stronger grasp of two-pointer technique ✅ Better problem-solving efficiency ✅ Cleaner and optimized linked list logic Simple problem, powerful pattern — this is how concepts build up 🚀 #LeetCode #DSA #Java #LinkedList #TwoPointers #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

I solved my 156th LeetCode problem last week. Problem 1 took me 40 minutes. I gave up. Googled the answer. Felt terrible. Problem 156 — I spotted the pattern What changed? Not intelligence. Not talent. Pattern recognition. Here is what 156 problems taught me: → Most problems are just combinations of 5 patterns → Two Pointers → Sliding Window → HashMap for fast lookups → Recursion with base cases → Sorting then searching Once you see the pattern, the problem becomes familiar. Even if you have never seen it before. The biggest mistake I made early on: I was solving problems randomly. Arrays today. Trees tomorrow. Graphs next day. No structure. No depth. Just random practice. Progress was slow and frustrating. The shift happened when I stopped solving randomly and started mastering one pattern at a time. 20 to 30 problems per pattern. Suddenly, problems that looked impossible became recognizable. The truth about LeetCode nobody tells you: It does not test intelligence. It tests pattern memory and calm thinking under pressure. Both are trainable. I am still learning. Still improving every day. But 156 problems taught me one thing clearly Consistency beats talent every single time. What is your current LeetCode count? Drop it below — no judgment! 👇 #DSA #LeetCode #BackendDevelopment #Java #JavaDeveloper #BuildInPublic #CareerTransition

💯 Daily Problem Solving – LeetCode Practice Today I solved 5 problems on LeetCode to improve my problem-solving and data structure skills. Problems solved: • 977 – Squares of a Sorted Array • 167 – Two Sum II (Input Array Is Sorted) • 319 – Bulb Switcher • 747 – Largest Number At Least Twice of Others • 11 – Container With Most Water While solving these problems, I practiced concepts like Two Pointers, Math Logic, and Array Traversal. Consistent practice on platforms like LeetCode helps improve logical thinking and coding efficiency for technical interviews. #LeetCode #ProblemSolving #Java #DSA #CodingPractice #SoftwareEngineering

Day 41 of 90 Days LeetCode Challenge 🚀 Today’s problem pushed me to think beyond traversal and focus on in-place tree manipulation. 🔍 Problem Insight : Given a binary tree, the goal was to flatten it into a linked list following preorder traversal (Root → Left → Right) — without using extra space. 💡 Intuition : Preorder traversal already gives the exact order we want. The challenge was to rearrange pointers instead of creating a new structure. For every node: If a left subtree exists, its rightmost node is the perfect place to attach the original right subtree. Then shift the left subtree to the right and set the left pointer to null. This preserves preorder order while flattening the tree in-place. 🧠 Approach : • Traverse the tree using a pointer • For each node with a left child: – Find the rightmost node of the left subtree – Attach the current right subtree there – Move left subtree to the right – Set left to null • Continue moving right ⏱️ Complexity : • Time: O(n) • Space: O(1) (no recursion, no stack) 📌 Key Learning : Sometimes the smartest solution isn’t about traversal , it’s about pointer rearrangement and tree restructuring. On to Day 42 tomorrow. Consistency > Motivation 💪 #LeetCode #DSA #BinaryTree #Java #ProblemSolving #CodingJourney #90DaysOfCode #SoftwareEngineering

Day 78 - LeetCode Journey Solved LeetCode 142: Linked List Cycle II (Medium) today — a powerful extension of the cycle detection problem. Earlier, we learned how to detect if a cycle exists. Now the challenge is to find the exact node where the cycle begins. 💡 Core Idea (Floyd’s Algorithm Extended): 1) Use slow & fast pointers to detect a cycle 2) Once they meet, reset one pointer to the head 3) Move both pointers one step at a time 4) The point where they meet again = start of the cycle 🤯 Why it works? Because of the mathematical relationship between distances traveled inside the cycle — both pointers align perfectly at the cycle entry point. ⚡ Key Learning Points: • Advanced use of two-pointer technique • Understanding the mathematics behind cycle detection • Solving without modifying the list • Maintaining O(n) time and O(1) space This is not just coding — this is algorithmic thinking at a deeper level. Also, this pattern connects with: -> Find duplicate number (cycle in array) -> Happy Number problem -> Loop detection in graphs ✅ Stronger conceptual clarity ✅ Better problem-solving depth ✅ Confidence with tricky pointer problems From detecting a cycle to pinpointing its start — that’s real progress 🚀 #LeetCode #DSA #Java #LinkedList #TwoPointers #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

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