Day 90: Solving LeetCode Problem 921 with Balance Counter

⚡ Day 97 of My LeetCode Journey — Problem 328: Odd Even Linked List 💡 Problem Insight: Today’s problem focused on rearranging a singly linked list so that all nodes at odd indices come first, followed by all even-indexed nodes — while maintaining their relative order. A great challenge to test how well you understand pointer manipulation! 🧠 Concept Highlight: The solution revolves around re-linking nodes using two pointers — one tracking odd nodes and another for even nodes. By carefully connecting them, we achieve the rearrangement in-place without extra space. It’s a smart exercise in linked list restructuring and pointer logic. 💪 Key Takeaway: Organizing efficiently — whether in data or in life — often means rearranging, not replacing. A small change in order can create big clarity. ✨ Daily Reflection: Linked lists truly train the mind to think sequentially and structurally — every link counts, just like every day of consistent learning. #Day97 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Pointers

Day 52 of the #90DaysWithDSA challenge is complete! Today continued our tree traversal journey with a problem that builds directly on yesterday's height calculation concepts. Today's Problem: Balanced Binary Tree (LeetCode 110 - Easy) The challenge: Determine if a binary tree is height-balanced. A height-balanced binary tree is defined as one where the left and right subtrees of every node differ in height by no more than 1. This problem is another perfect application of post-order traversal with early termination: The Approach: Use DFS to calculate heights of left and right subtrees At each node, check if the height difference between left and right subtrees is ≤ 1 If any node violates this condition, propagate a failure signal upward Return the height of the current node for parent calculations, or a special value (-1) to indicate imbalance This optimized approach runs in O(n) time and avoids redundant calculations by checking balance during height computation. Key Takeaway: Many tree validation problems can be solved efficiently by combining the computation (like height) with the validation check during traversal. The early termination optimization is crucial for efficiency - once we detect imbalance, we can stop further computation. 52 days of consistent coding. The recursive patterns for tree problems are becoming second nature! 🚀 Let's keep balancing our tree knowledge together! 👉 Want to master tree validation and optimization techniques? JOIN THE QUEST! Comment "Balancing with you!" below and share what tree problem you're solving today. 👉 Repost this ♻️ to help other developers discover this challenge and improve their recursive thinking skills. What's your favorite tree validation problem? #Day52 #BinaryTree #BalancedTree #DFS #Recursion #CodingInterview #Programming #SoftwareEngineering #Tech #LearnInPublic #Developer #LeetCode #ProblemSolving

Day 52 of #100DaysOfCode 🧩 Problem: 3321. Find X-Sum of All K-Long Subarrays II Difficulty: Hard This version builds on the easier “Find X-Sum” problem, but the constraints are massive — meaning brute force dies instantly. The goal is to maintain the sum of top x most frequent elements for every subarray of size k, with efficient updates as the window slides. 💡 What I learned: Balancing efficiency and correctness in sliding window problems is tricky. Frequency tracking with ordered structures (like multiset or heap) keeps updates O(log n). Rebalancing the “top x” elements correctly after each update is crucial to avoid stale counts. 🧠 Key takeaway: Optimization isn’t about shaving milliseconds; it’s about understanding how to reuse work instead of starting over every time. Every “Hard” problem eventually boils down to patience, debugging, and a little bit of emotional damage. #LeetCode #C++ #DSA #ProblemSolving #100DaysOfCode #CodingJourney

🚀 Day 52 of LeetCode 150 Days Challenge — Valid Parentheses #Day52 #LeetCode150 #CodingChallenge #DSA #Stack #Cplusplus #LeetCode #150DaysOfCode #CodeEveryday #LearnToCode #ProblemSolving #SoftwareEngineering #SDEPreparation #InterviewPrep 🧩 Problem Statement Given a string s containing only the characters '(', ')', '{', '}', '[', and ']', determine if the input string is valid. 👉 A string is valid if: Open brackets are closed by the same type of brackets. Brackets are closed in the correct order. ⚙️ Intuition This problem is about balancing parentheses — every opening bracket must have a matching closing one in order. A stack is perfect here since it follows LIFO (Last-In-First-Out) order: Push opening brackets onto the stack. When a closing bracket appears, check if it matches the top of the stack. If it matches → pop it. If not → invalid. At the end, if the stack is empty → it’s valid. 🧠 Example Dry Run Input: s = "{[()]}" Process: { → push [ → push ( → push ) → matches ( → pop ] → matches [ → pop } → matches { → pop Stack is empty → ✅ Valid ⏱ Complexity Analysis Time: O(n) — one pass through string Space: O(n) — for the stack 🌱 Takeaway This problem reinforces: Stack fundamentals Parentheses matching logic Edge case handling (unbalanced or extra closing brackets)

🚀 Day 47 of Solving LeetCode – Slow Steps, Strong Patterns 🧩 Problem: Merge Two Sorted Lists A classic linked-list problem where you merge two already sorted lists into one sorted list. 🧠 Concepts / Techniques Used: Linked List manipulation Two-pointer technique Dummy node pattern Iterative merging logic ✨ Learning Reflection: Today’s problem reinforced how powerful the dummy node pattern is when working with linked lists. It not only simplifies edge cases but also keeps the code cleaner and easier to reason about. Every time I revisit linked list problems, I feel my confidence improving — one small win at a time. 📊 Performance Stats: 🏆 Runtime: 0 ms (Beats 100%) 💾 Memory: 17.96 MB 💡 Closing Line: Step by step, problem by problem — this journey is shaping me into a better thinker and engineer. Consistency always pays off. 🚀 🔖 Hashtags: #LeetCode #Day47 #DSA #LinkedList #100DaysOfCode #CodingJourney #SoftwareEngineering #ProblemSolving #MERN #AnkitCodes

🚀 #Day57 of #100DaysOfLeetCodeHard 📘 Problem: [LeetCode 2547 – Minimum Cost to Split an Array] My Submission:https://lnkd.in/gB2aQ9TS This one was a really interesting DP + preprocessing problem that tested both efficiency and clarity of thought. 💡 Approach: The key idea was to precompute the cost of every possible subarray [i...j], where cost represents the number of elements that appear more than once (the trimmed part). Once precomputed, the problem transforms into a simple Dynamic Programming formulation: dp[i] = min( k + cost[i][j] + dp[j+1] ) for all j ≥ i This way, we can efficiently find the optimal points to split the array, minimizing the total cost. Given the constraints (n ≤ 1000), an O(n²) preprocessing and DP approach works perfectly. 🧮 Complexity: Time: O(n²) Space: O(n²) A neat problem that beautifully combines frequency tracking, preprocessing, and classic DP — a great example of how strong intuition can simplify what initially looks intimidating. #100DaysOfLeetCodeHard #Day57 #LeetCode #DynamicProgramming #ProblemSolving #DSA #CompetitiveProgramming #Precomputation

🌟 Day 105 of My LeetCode Journey — Problem 138: Copy List with Random Pointer 💡 Problem Insight: Today’s problem took linked lists to a new level — each node had not just a next pointer but also a random pointer that could point to any node (or null). The challenge was to create a deep copy of such a list, preserving both connections perfectly. 🧠 Concept Highlight: The efficient approach involves three smart steps: Clone each node and insert it right next to the original node. Set up random pointers for the cloned nodes. Detach the two lists to restore the original and extract the copy. This clever interleaving technique avoids extra space (no hash map needed) and runs in O(n) time — an elegant display of pointer manipulation. 💪 Key Takeaway: Duplication isn’t about copying blindly — it’s about understanding the relationships and structure beneath the surface. ✨ Daily Reflection: This problem reinforced that clean logic and visualization make even the most pointer-heavy tasks simple and satisfying. #Day105 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #RandomPointer #DeepCopy #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

#Day57 of my LeetCode Journey 🚀 Continuing with Linked List problems. 🧩 Question #160 – Intersection of Two Linked Lists (Easy) Brute Force Approach: 1) Traverse both linked lists and store nodes of the first list in a hash map.   2) Then, traverse the second list and check if any node already exists in the map.   3) The first repeated node is the intersection point.   - Time Complexity: O(N + M)   - Space Complexity: O(N)  Better Approach: 1) Find the lengths of both linked lists.   2) Calculate the difference between the two lengths.   3) Move the pointer of the longer list ahead by that difference.   4) Then move both pointers one step at a time until they meet.   5) The meeting point is the intersection node.   - Time Complexity: O(N + M)   - Space Complexity: O(1)  Optimal Approach (Two Pointer Technique): 1) Use two pointers, `t1` and `t2`, initialized at the heads of both lists.   2) Move both pointers one step at a time.   3) When one pointer reaches the end, redirect it to the head of the other list.   4) Eventually, both pointers will meet at the intersection node (or None if no intersection).   - Time Complexity: O(N + M)   - Space Complexity: O(1)  ✨ That’s it for Day 57. The journey continues — see you on Day 58. Happy coding! 🚀  #Day57 #LeetCodeJourney #LeetCode #LinkedList #Intersection #TwoPointerTechnique #DSA #PythonPrep

🔗 Day 63 of #100DaysOfCode 🔗 🔹 Problem: Valid Parentheses – LeetCode ✨ Approach: Implemented a stack-based validation to ensure every opening bracket has a matching closing one in correct order. Each character is checked systematically — pushing opens and popping closes — making it both clean and efficient! ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the string Space Complexity: O(n) — stack usage for unmatched brackets ✅ Runtime: 2 ms (Beats 97.47%) ✅ Memory: 41.96 MB 🔑 Key Insight: Stacks are the unsung heroes of structured logic — from parentheses validation to syntax parsing, they keep the balance just right. 🧠 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Stack #AlgorithmDesign #CodeJourney #ProgrammingChallenge #LogicBuilding #Efficiency #CodingDaily

Day 47 — #100DaysOfLeetCode 🚀 Problem: Reverse Words in a String (LeetCode 151) ✅ Approach: Trim spaces, split the string, reverse the words, and join them back. ⚡ Complexity: O(n) Learning: Improved string handling and manipulation efficiency 🔁 Every line of code adds clarity and confidence 💪 #LeetCode #100DaysOfCode #DSA #Strings #ProblemSolving #CodingJourney