Mastering Binary Tree Depth with LeetCode 104

Day 53 :- 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 𝗠𝗮𝘁𝗰𝗵𝗶𝗻𝗴 𝗶𝗻 𝗦𝘁𝗿𝗶𝗻𝗴𝘀: 𝗜𝘀𝗼𝗺𝗼𝗿𝗽𝗵𝗶𝗰 𝗦𝘁𝗿𝗶𝗻𝗴𝘀 🔤🔁 Today’s DSA session was about understanding character mapping and pattern consistency using LeetCode 205: Isomorphic Strings. This problem is a great way to strengthen understanding of hashing + mapping patterns in strings. 🔹 𝗧𝗵𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴 Given two strings s and t, determine if they are isomorphic. 👉 Two strings are isomorphic if characters in s can be replaced to get t, while maintaining order. 👉 No two characters can map to the same character (one-to-one mapping). 🔹 𝗧𝗵𝗲 𝗞𝗲𝘆 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 💡 This problem combines: • Character mapping • Tracking last seen positions 👉 Instead of explicitly storing mappings, we track last occurrence index of characters. 🔹 𝗖𝗼𝗿𝗲 𝗟𝗼𝗴𝗶𝗰 ✔️ If lengths are different → return false ✔️ Use two arrays to track last seen positions: • lastS for string s • lastT for string t ✔️ For each index i: • If last occurrence of s[i] ≠ last occurrence of t[i] → not isomorphic • Update both with i + 1 👉 Using i + 1 avoids confusion with default value 0 🔹 𝗪𝗵𝘆 𝗧𝗵𝗶𝘀 𝗪𝗼𝗿𝗸𝘀 👉 Ensures consistent mapping pattern 👉 If two characters behaved differently before → mismatch detected 👉 No need for complex hash maps 🔹 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆 ⚡ • Time Complexity → O(n) • Space Complexity → O(1) (fixed size arrays) 🔹 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 💡 👉 Pattern problems can often be solved using last seen indices 👉 Always think of simpler representations before jumping to hash maps 👉 Consistency in mapping is more important than actual values 🙏 Huge thanks to my mentors Anchal Sharma and Ikshit .. for guiding me in recognizing patterns in string problems. This approach makes many problems much simpler! #DSA #Java #100DaysOfCode #Strings #Hashing #ProblemSolving #Mentorship #LeetCode #SoftwareEngineering #CodingJourney 🚀

🔥 Day 31/100 – DSA Problem Solving 📌 Problem: 412. Fizz Buzz (LeetCode) Today’s problem looks simple, but it really tests your logic building and attention to detail. 💡 My Approach: I used a loop from 1 to n For each number: If divisible by both 3 & 5 → "FizzBuzz" If divisible by 3 → "Fizz" If divisible by 5 → "Buzz" Otherwise → convert number to string 🧠 What I Learned Today: ✅ Importance of using the correct variable inside loops ✅ Order of conditions matters (3 & 5 first) ✅ Writing clean and readable logic ✅ Even easy problems can teach debugging skills 🚀 Key Takeaway: Don’t underestimate easy problems — they help build strong fundamentals and improve problem-solving thinking. 💻 Code Concept: Used simple loop + conditional statements + list to store results. #Day31 #100DaysOfCode #DSA #LeetCode #Java #CodingJourney #ProblemSolving

🚀 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 6 of LeetCode Problem Solving Solved today’s problem — LeetCode #1480: Running Sum of 1d Array 💻🔥 ✅ Approach: Prefix Sum (Running Sum) ⚡ Time Complexity: O(n) 📊 Space Complexity: O(n) The task was to compute the running sum of an array where each element represents the sum of all previous elements including itself. 👉 Example: Input: [1,2,3,4] Output: [1,3,6,10] 💡 Key Idea: Keep adding elements as you traverse the array and store the cumulative sum. 👉 Core Logic: Initialize sum = 0 Traverse array Add current element → sum += nums[i] Store in result array 💡 Key Learning: Simple problems help build strong fundamentals — mastering basics like prefix sum is very important for advanced problems. Grateful to my mentor Pulkit Aggarwal — your guidance is helping me strengthen my fundamentals every day 🙌 Consistency is the key — small steps lead to big results 🚀 #Day6 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode

Day 51 of My 90-Day Coding Challenge Today’s focus was on recursion, and honestly — it’s not as simple as it looks. I solved Letter Combinations of a Phone Number, which seems straightforward at first, but quickly tests how well you actually understand recursive thinking. The real challenge wasn’t writing code — it was thinking in terms of: • Breaking the problem into smaller subproblems • Building combinations step by step • Managing the recursive flow correctly Key learning: Recursion is not about memorizing patterns — it’s about visualizing the decision tree and trusting the process. One mistake I noticed: If you don’t clearly understand the base case and transitions, recursion becomes confusing very fast. What improved today: • Better clarity on how combinations are formed • Stronger grip on recursion structure (index + choices) • More confidence in handling backtracking-style problems Hard truth: Recursion feels difficult because the thinking is different — not because the problem is hard. And that’s exactly why it’s important to master it. #90DaysOfCode #DSA #Java #Recursion #Backtracking #LeetCode #ProblemSolving

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 56 of my DSA Journey Today, I worked on a Hard-level problem from LeetCode: 👉 Problem #4 – Median of Two Sorted Arrays (LeetCode) This problem is well-known for its complexity and is frequently asked in top product-based companies. 💡 What I focused on: Understanding the problem deeply instead of jumping directly to the optimal solution Implementing a merge + sort approach to build a clear foundation Applying the two-pointer technique to efficiently identify the median Handling both odd and even length cases carefully ⚙️ Approach Used: Merged both input arrays into a single array Sorted the combined array Used two pointers (i and j) moving towards the center Determined the median based on whether the length is odd or even 📈 Key Learning: Even though the optimal solution has a time complexity of O(log(min(m, n))), building a correct and intuitive approach first is crucial. It strengthens problem-solving skills and helps in understanding advanced techniques later. 🎯 Takeaway: Consistency and clarity in logic are more important than immediately writing the most optimized code. 🔥 Step by step, moving closer to mastering Data Structures & Algorithms. #DSA #LeetCode #ProblemSolving #Java #CodingJourney #PlacementPreparation #Consistency #Learning

“What I learned after solving 300+ LeetCode problems 👇” At the beginning, I made a mistake. I kept solving random problems every day thinking: “More problems = more skill” But I was wrong. I realized that solving problems randomly is mostly a waste of time if you don’t understand the pattern behind them. Everything changed when I started focusing on patterns instead of problems. Here are some important patterns I learned: • Sliding Window • Two Pointers • Prefix Sum • Binary Search • Recursion & Backtracking • Linked List Patterns • Stack & Monotonic Stack • Hashing / Frequency Count Once you understand these patterns: You don’t need to solve 1000 problems. You start recognizing solutions instantly. Now when I see a problem, I don’t panic. I ask: 👉 “Which pattern does this belong to?” That one question changed everything for me. Still learning, but now with direction 🚀 #DSA #LeetCode #Java #BackendDevelopment #CodingJourney

🚀 Day 40 of My 100 Days Coding Challenge Not every problem is about finding an element — sometimes, it's about finding where it should be. Today’s problem, Search Insert Position, reinforced a key concept in algorithm design: 👉 Efficiency is not just about solving the problem, but solving it the right way. Instead of a linear approach, I implemented an optimal Binary Search solution (O(log n)), ensuring scalability and performance. 💡 What I Focused On Writing an efficient solution rather than a brute-force approach Understanding how boundary conditions impact the result Realizing that the final pointer position can represent the answer 📊 Outcome ✅ All test cases passed ⚡ Runtime: 0 ms (Beats 100%) 💾 Memory Usage: Optimized 🧠 Takeaway Small problems often carry big lessons. Today’s learning reminded me that mastering fundamentals like binary search is crucial for tackling complex challenges ahead. 🔁 Consistency 40 days in — and still going strong 💪 Discipline and consistency are slowly turning into confidence. #100DaysOfCode #Day40 #Java #BinarySearch #LeetCode #DSA #ProblemSolving #SoftwareEngineering #CodingJourney 🚀

Day 75 of My DSA Journey Today’s problem: Reverse Bits (LeetCode 190) At first glance, it looks simple—but it really tests your understanding of bit manipulation 🔹 What I learned today: • How to extract the last bit using n & 1 • Building a reversed number using left shift • Importance of running exactly 32 iterations (handling leading zeros!) • Thinking in terms of binary, not decimal 🔹 Key Idea: Take bits from right to left and rebuild the number from left to right. 💡 This problem helped me get more comfortable with low-level operations—something that’s super useful for writing efficient code. 📈 Progress Update: 75 days of consistency! Small steps every day are building strong problem-solving skills #DSA #100DaysOfCode #Java #CodingJourney #LeetCode #BitManipulation #Consistency #Learning