Solving Container With Most Water in O(n) with Two-Pointer Technique

🎯 Day 81 of #100DaysOfCode 🎯 🔹 Problem: Reverse Only Letters – LeetCode ✨ Approach: Used a two-pointer strategy to reverse only the alphabetic characters while keeping all non-letter characters in their original positions. By moving pointers inward and swapping only when both characters are letters, the solution stays efficient and elegant! 🔄✨ 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each character visited at most once 💾 Space Complexity: O(n) — due to character array construction ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.96 MB 🔑 Key Insight: Sometimes, all you need is smart pointer movement — not everything needs to be reversed, only the right pieces. #LeetCode #100DaysOfCode #DSA #TwoPointers #StringManipulation #ProblemSolving #CleanCode #AlgorithmDesign #CodingChallenge

🚀 LeetCode Challenge Complete! Just solved "Ones and Zeroes" - a brilliant 0/1 knapsack problem with TWO constraints, showcasing optimization from 3D to 2D DP! 💡 Solution Approaches: Approach 1 - 3D Memoization (Top-Down): ✅ State: dp[index][m_remaining][n_remaining] ✅ For each string: take or skip decision ✅ Count ones and zeros for each string ✅ Memoize results to avoid recomputation ✅ Space: O(len × m × n) Approach 2 - 2D Space-Optimized (Bottom-Up): ✅ State: dp[m_used][n_used] = max strings ✅ Process each string sequentially ✅ Backward iteration prevents using same string multiple times! ✅ Space: O(m × n) ✨ The key insight: This is 0/1 knapsack with TWO constraints (m zeros, n ones). Approach 1 is intuitive with explicit take/skip decisions. Approach 2 optimizes space by processing strings one at a time and iterating BACKWARD through capacities (classic knapsack trick to ensure each item used at most once). Why backward iteration? Prevents overwriting values we still need in current iteration! Time: O(len × m × n) | Space: O(len × m × n) → O(m × n) #LeetCode #DynamicProgramming #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #Knapsack

💡 Day 77 of #100DaysOfCode 💡 🔹 Problem: Majority Element – LeetCode ✨ Approach: Used a sorting-based strategy to quickly identify the majority element. By sorting the array, the middle element naturally becomes the majority — simple, clean, and surprisingly powerful! 🌟 📊 Complexity Analysis: ⏱ Time Complexity: O(n log n) — due to sorting 💾 Space Complexity: O(1) — constant auxiliary space ✅ Runtime: 7 ms (Beats 39.33%) ✅ Memory: 55.75 MB 🔑 Key Insight: Sometimes the smartest solution is also the simplest — a little ordering can reveal the dominant pattern hiding in plain sight. ✨ #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #CodingDaily #ProgrammingChallenge #Sorting #LogicBuilding #CodeJourney

🔗 Day 75 of #100DaysOfCode 🔗 🌳 Problem: Binary Tree Postorder Traversal – LeetCode ✨ Approach: Implemented a recursive depth-first traversal that processes the left subtree, then right subtree, and finally the root node — perfectly matching the postorder pattern (Left → Right → Root). The solution is clean, intuitive, and highlights the elegance of recursion in tree traversal! 🌿 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each node is visited exactly once 💾 Space Complexity: O(n) — recursion stack in the worst case (skewed tree) ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 43.07 MB 💡 Key Insight: Recursion beautifully mirrors the natural hierarchy of trees — by trusting the call stack, we achieve simplicity and clarity in solving even complex traversal problems. 🌱 #LeetCode #100DaysOfCode #ProblemSolving #DSA #BinaryTree #Recursion #AlgorithmDesign #CodeJourney #ProgrammingChallenge #LogicBuilding #Efficiency #CodingDaily

Every firm thinks their shared drive is “pretty organised.” Until two engineers open different versions of the same drawing. Reci’s folder structure looked good on paper - neat, nested, labelled. But behind it was quiet chaos: no one really knew which file was the latest, which had been checked, or what was actually issued. We fixed it by scripting the boring stuff. Every night, Python automatically archived old drawings, surfaced only the latest, and logged what had been sent out. No new software. Just a bit of logic layered on top of their existing server. The result? Clarity. Consistency. Zero “which version are we on?” moments. Takeaway: A tidy folder structure looks organised. Automation makes it stay organised. Read more here: https://lnkd.in/em3eTAFq

🚀 LeetCode Challenge Complete! Just solved "Increment Submatrices by One" - a perfect demonstration of the difference array technique for efficient range updates! 💡 Solution Approach: ✅ Phase 1 - Mark boundaries: For each query, add +1 at start column, -1 after end column ✅ Phase 2 - Prefix sum: Accumulate row-wise to get final values ✅ Optimization: Instead of updating entire submatrix, just mark endpoints! The key insight: This is the classic difference array pattern! Instead of incrementing every cell in a range, we mark the boundaries: - Add +1 at the start of the range - Add -1 just after the end of the range - Then do prefix sum to "materialize" the actual values Why it works: Without optimization: Update every cell in [c1, c2] for rows [r1, r2] → O(rows × cols) per query With difference array: Mark 2 positions per row → O(rows) per query Final prefix sum: O(n²) once at the end Example: Range [1,2] in row 0 - Before prefix: [0, +1, 0, -1, 0] - After prefix: [0, 1, 1, 0, 0] ✓ Time: O(q×n×n) → O(q×n + n²) | Space: O(n²) #LeetCode #DifferenceArray #CPlusPlus #Algorithms #SoftwareEngineering #ProblemSolving #RangeUpdate #Optimization

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 68 of #100DaysOfLeetcodeHard — LeetCode 2382: Maximum Segment Sum After Removals (Hard) My Submission:https://lnkd.in/g-X4k2Hd Today’s challenge was a Disjoint Set Union (Union-Find) problem with a clever reverse processing approach. 🧩 Problem Summary: We start with an array and remove elements one by one, needing to track the maximum segment sum of contiguous non-removed elements after each removal. Instead of simulating removals forward (which is difficult to track), we reverse the process — ✅ Start from an empty array and add elements back in reverse order. ✅ Use Union-Find (Disjoint Set) to merge adjacent active segments and maintain their sums dynamically. 💡 Approach: Each index starts as its own segment with rank[i] = nums[i] (used to store segment sums). When a new index is added, we union it with its active neighbors (if any). Track the maximum segment sum after each merge. 🧠 Key Concepts Used: Union-Find with path compression & rank to efficiently merge contiguous segments. Reverse iteration to avoid handling splits directly. 📈 Complexity: Time: O(n α(n)) ≈ O(n) (inverse Ackermann function for DSU) Space: O(n) A beautiful mix of data structures + reverse simulation + problem insight — one of those problems that truly sharpen algorithmic thinking. ⚡ #LeetCode #UnionFind #DSU #ProblemSolving #AlgorithmDesign #DataStructures #CodingChallenge #100DaysOfCode #LearningEveryday

🌟 Day 84 of #100DaysOfCode 🌟 🔹 Problem Solved: Check If All 1's Are at Least K Places Away – LeetCode Today’s challenge was all about precision, pattern detection, and distance validation within a binary array. The goal? Ensure every 1 is properly spaced and respects the minimum distance k. ✨ Approach: I iterated through the array, tracked the position of each 1, and checked the gap before encountering the next one. A simple but effective two-pointer style logic! 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — constant extra memory 🚀 Performance: ✔ Runtime: 1 ms (Beats 99.71%) ✔ Memory: 65.68 MB 🔑 Key Insight: Even a straightforward problem can sharpen your ability to detect patterns and handle constraints efficiently. Small details—like distances between bits—can make or break logic. #LeetCode #DSA #CodingChallenge #100DaysOfCode #ProblemSolving #BinaryArray #Algorithms #TechJourney #CodeEveryday #JavaCoding

✅ Day 83 of #100DaysOfLeetCode 🧩 Problem: Sliding Window Maximum 🔗 LeetCode 239 | Difficulty: Hard 📄 Problem Statement: Given an integer array nums and an integer k, return the maximum value in each sliding window of size k as it moves from left to right. 🧠 Approach (Monotonic Deque): 💡 The key insight is that for each window, we only need to track potential maximums — the rest can be ignored efficiently using a deque. The deque stores indices, not values. The deque is always maintained in decreasing order of values (nums[dq.front()] is the current max). Steps: For each new element: Remove all indices from the back whose values ≤ current value (nums[i]). Add the new index i. Remove the front element if it goes out of the current window (i - k). The front of deque always gives the maximum for the current window. 📊 Complexity Analysis: Time: O(n) — Each element is added and removed at most once. Space: O(k) — Deque can hold up to k elements. 🏆 Result: ✔ Runtime: 32 ms (Beats 32.8%) ✔ Memory: 139.26 MB (Beats 34.6%) 💡 Key Takeaway: The monotonic deque is one of the most elegant O(n) solutions for “window max/min” type problems. It’s efficient, clean, and avoids unnecessary heap or tree overhead. #Day83 #LeetCode #SlidingWindow #Deque #DataStructures #Cplusplus #ProblemSolving #100DaysOfCode