Mastering Trees in LeetCode with Recursion and DFS

Day 44 of #100DaysOfCode Consistency is starting to compound — and today’s problem was a perfect example of how structured thinking leads to efficient solutions. I worked on the “Product of Array Except Self” problem on LeetCode, which initially looks simple but pushes you to think beyond brute force. 🔍 What makes this problem interesting? * You cannot use division * You must achieve O(n) time complexity * You need to optimize space usage 💡 My Approach & Learnings: Instead of calculating the product repeatedly, I broke the problem into two smart passes: 1. Prefix pass → storing product of all elements to the left 2. Suffix pass → multiplying with product of elements to the right This helped me: ✔ Avoid redundant calculations ✔ Improve efficiency ✔ Write clean and optimized code ⚙️ Skills Strengthened: * Problem decomposition * Optimized array traversal techniques * Space-time tradeoff understanding * Writing production-level clean C++ code 📈 Why this matters? Problems like these build the foundation for tackling real-world scenarios where performance and scalability are critical. It’s not just about solving — it’s about solving efficiently and elegantly. Every day of this journey is improving how I think, not just how I code. Looking forward to pushing further #Day44 #100DaysOfCode #LeetCode #DSA #CodingJourney #SoftwareEngineering #ProblemSolving #Algorithms #Cplusplus #TechSkills #DeveloperJourney #PlacementPreparation #CodeDaily #LearnToCode #GrowthMindset #FutureEngineer #Consistency #CodingLife

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

100 LeetCode Problems: Pattern Recognition Over Problem Count Hit 100 LeetCode submissions. The breakthrough wasn't volume — it was realizing most problems are variations of ~15 core patterns. What Actually Changed: Early problems felt unique. Now I see combinations of known techniques. Two pointers, sliding windows, HashMaps aren't isolated tricks — they're building blocks that compose. "New" problems become: identify 2-3 familiar patterns, combine them, execute. The Real Skill: Decomposition. "Longest substring without repeats" = variable sliding window + HashSet. "3Sum" = sorted array + n iterations of two pointers. Honest Take: Grinding works not because you memorize solutions, but because repetition builds pattern recognition instincts. You stop asking "how do I solve this?" and start asking "which patterns apply here?" 100 down. Goal isn't 1000 problems — it's deeply understanding the patterns that make 900 of them variations on these 100. #LeetCode #PatternRecognition #CodingInterview #100Problems #AlgorithmDesign #SoftwareEngineering

24 Hours. One Problem. One Solution. You never truly know how productive you can be until inspiration hits at 3:00 AM. It started with a simple frustration during a uni assignment: I was tired of the total lack of standard code documentation for Shell scripts. I originally planned to tackle this after the term ended, but the idea became too intense to ignore. The result? A 24-hour non-stop sprint of engineering, AI collaboration, and pure "vibe coding." I’m excited to launch shDoc — a JSDoc-style documentation engine for Shell. 🐚💡 What it does: • Brings JSDoc intelligence to the bash environment. • Enables hover intelligence and symbol tracking for your functions. • Supports 84+ standard JSDoc tags (like @param) right in VS Code. • Features "sheDoc" script headers for global metadata. I built this because I believe in creating useful tools for all people. If you've ever looked at a 500-line .sh file and wondered what "$1" actually was, this is for you. After being hyper-productive, I am now officially hyper-inactive. Time to crash, but I’m already looking forward to the next moment like this. 🛌💤 Try it on VS Code: https://lnkd.in/gEBE2U6W Star the project on GitHub: https://lnkd.in/g9TTEgqc #BuildInPublic #DevOps #VSCode #ShellScripting #Programming #OpenSource

Day 65/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 204 – Count Primes (Medium) 🧠 Approach: Create a boolean array to mark prime numbers and iteratively mark multiples of each prime as non-prime. 💻 Solution: class Solution:   def countPrimes(self, n: int) -> int:     if n <= 2:       return 0           isPrime = [True] * n     isPrime[0] = isPrime[1] = False           i = 2     while i * i < n:       if isPrime[i]:         for multiple in range(i * i, n, i):           isPrime[multiple] = False       i += 1           return sum(isPrime) ⏱ Time | Space: O(n log log n) | O(n) 📌 Key Takeaway: The Sieve of Eratosthenes efficiently finds all prime numbers up to n by eliminating multiples of each prime. #leetcode #dsa #development #problemSolving #CodingChallenge

🚀 Day 76 / 100 Days of LeetCode Challenge 🧠 Today’s problem: Minimum Operations to Transform a Binary String I worked on a problem that required counting the number of 0s in a binary string and determining the minimum operations needed based on a given integer k. 📌 Problem intuition: Count the number of zeros in the string. If there are no zeros → already valid → return 0. If the string length equals k and all characters are zeros → 1 operation needed, otherwise -1. Otherwise, compute hase = len - k and proceed with further logic (though the implementation is still in progress). 🔍 Key takeaway: Sometimes the simplest approach—like counting zeros—can form the foundation of a solution. But edge cases like len == k and zero-count logic must be handled carefully to avoid incorrect results. 💻 Code snippet highlights: Loop through string, using bitwise operation ~s.charAt(i) & 1 to count zeros efficiently. Early returns for edge cases. Still refining the full logic, but proud of the progress! 📈 Runtime: 4 ms (Beats 99.66%) 💾 Memory: 47.68 MB (Beats 87.62%) ✅ 999/999 test cases passed #100DaysOfCode #LeetCode #CodingChallenge #Java #ProblemSolving #Algorithms #DataStructures #DeveloperJourney #TechCommunity #DailyCoding #CodeNewbie #WomenInTech #Programming #DevLife #LearnToCode #CodingLife #SoftwareEngineering #Tech #GrowthMindset

Day 6 of My LeetCode Consistency Journey Today I solved Longest Consecutive Sequence (LeetCode 128). At first, my instinct was to sort the array and then check for consecutive elements. But sorting leads to O(n log n) time complexity, while the problem expects an O(n) solution. After thinking through it, I realized the key idea is to use hashing. 💡 Main insight: A number should only start a sequence if (num - 1) does not exist. This ensures we only start counting from the beginning of a sequence and avoid unnecessary checks. From there, the sequence can be expanded using num + 1 until the chain breaks. Key learnings from today: • Using a hash set for O(1) lookup can drastically improve performance. • Identifying the start of a sequence avoids redundant computation. • Small implementation details matter — like not modifying the loop variable during iteration. This problem was a great reminder that sometimes the real challenge is recognizing the pattern, not writing the code. Day by day, the goal remains the same: consistency and better problem-solving thinking. #LeetCode #DSA #ProblemSolving #CodingJourney #Consistency

Day 79 - LeetCode Journey 🚀 Solved LeetCode 203: Remove Linked List Elements (Easy) — a deceptively simple problem that strengthens core linked list fundamentals. At first, it feels like just removing nodes with a given value. But the real challenge lies in handling edge cases cleanly, especially when deletions happen at the head or consecutively. 💡 Core Idea (Dummy Node + Pointer Control): Introduce a dummy node pointing to head Use a pointer (prev) to traverse the list If prev.next.val == target, skip the node Otherwise, move the pointer forward This ensures safe deletion without losing track of the list. 🤯 Why it works? Because the dummy node acts as a stable anchor, allowing uniform handling of all cases — including when the head itself needs to be removed. ⚡ Key Learning Points: • Importance of dummy node in linked list problems • Handling edge cases like head deletion • Managing consecutive deletions efficiently • Clean pointer manipulation without breaking links • Achieving O(n) time and O(1) space This problem builds the foundation for many advanced linked list operations. Also, this pattern connects with: <>Remove Nth Node from End <>Delete Node in Linked List <>Remove Duplicates (I & II) <>Partition List ✅ Stronger understanding of pointer-based logic ✅ Better handling of tricky edge cases ✅ Writing clean and robust linked list code Mastering these basics is what makes complex problems easier later 🚀 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

🚀 Day 74 of LeetCode Problem Solving Journey — 100 Days LeetCode Challenge Today, I solved LeetCode #876 — Middle of the Linked List using C++, under the guidance of Trainer NEKAL SINGH SALARIA Singh at REGex Software Services. 🔍 Problem Summary: Given the head of a singly linked list, return the middle node of the list. If there are two middle nodes, return the second middle node. 🧠 Approach Used (Two Pointer Technique): I used the slow and fast pointer approach: Initialize two pointers → slow and fast Move slow by one step and fast by two steps When fast reaches the end → slow will be at the middle Return the slow pointer This approach efficiently finds the middle in a single traversal. 📚 Key Learnings of the Day ✔ Two-pointer technique is very useful for linked list problems ✔ Fast pointer helps reduce the number of traversals ✔ This method naturally handles both odd and even length lists ✔ Efficient pointer movement simplifies logic ⏱ Complexity • Time Complexity: O(n) • Space Complexity: O(1) 💡 Optimization Insight: This is the optimal approach since it finds the middle in one pass without using extra space. An alternative approach using array storage would increase space complexity. Consistency is building strength — see you on Day 75 🚀 #Day74 #100DaysLeetCodeChallenge #LeetCode #RegexSoftwareServices #NekalSingh #ProblemSolving #DSA #CPlusPlus #CodingChallenge #ProgrammingJourney #LinkedList #KeepGrowing

Someone just asked on the n8n community forum what tech stack to learn for 'enterprise-grade automations that actually stay running.' Their current setup with n8n and Make.com keeps breaking under real client load. This is the question I see constantly, and it's usually backwards. The problem isn't that Python or Node.js are magically more reliable than no-code tools. It's that no-code platforms are doing the heavy lifting for you, so when you hit their limits, you've got nowhere to go. You're not building — you're configuring. And there's a ceiling. I've watched clients do exactly this. They outgrow Make.com, panic, then spend months learning a language when what they actually needed was to understand what broke in the first place. Here's what I'd actually tell someone in that position: 1. Before picking a language, understand your actual bottleneck. Is it API rate limiting? Error handling? Database design? Most of the time it's not the language, it's the architecture. 2. If you genuinely need to move to proper code, Node.js with TypeScript is the obvious choice if you're already comfortable with JavaScript in n8n. You're not relearning everything from scratch. 3. Python works if you're doing heavy data transformation or integrations with libraries that only exist in the Python ecosystem. But it's slower at scale and overkill for most 'bulletproof reliability' problems. What I don't see people asking is the harder question: do you actually need to rewrite this, or do you need to architect it differently within the constraints you've got? I've fixed more 'we need to rebuild this' problems by adding proper error handling, retry logic, and monitoring than I have by switching languages. What's your experience been? Have you hit the ceiling with no-code tools, or have you just not built the guardrails properly yet? https://lnkd.in/gC5pt-ya