Solved Matrix Diagonal Sum in O(n) time with clarity

🎯 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

🚀 Day 7 of #120DaysOfCode Challenge 💡 Problem: Reverse Integer (LeetCode #7 | Medium) 📄 Problem Statement: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes it to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], then return 0. 🧩 My Approach: Extract the last digit of x using % 10. Build the reversed number step by step using rev = rev * 10 + digit. Carefully check for overflow before multiplying or adding — using INT_MAX and INT_MIN limits to ensure the reversed number stays valid. If overflow is detected, return 0. 🔍 Key Learnings: How to handle integer overflow without using 64-bit variables. Importance of edge case testing and boundary conditions. Reinforced understanding of modulus (%) and integer division (/) operations. 🔥 Progress: Day 7 / 120 📚 Language: C 🏁 Problem Solved: Reverse Integer (LeetCode #7) Every problem is a small step toward stronger logic and cleaner code! 💪 #100DaysOfCode #120DaysOfCode #CodingChallenge #LeetCode #CProgramming #ProblemSolving #LearnEveryday #BuildInPublic

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency

🚀 Day 143 of #150DaysOfCode on LeetCode Problem: 2257. Count Unguarded Cells in the Grid Today’s challenge was a fun simulation and grid traversal problem! 🧩 In this task, we’re given a grid with guards and walls, and we must determine how many cells remain unguarded. Each guard can monitor cells in four directions — up, down, left, and right — until they’re blocked by a wall or another guard. This problem beautifully blends matrix manipulation, directional traversal, and boundary checks — concepts that often appear in real-world simulation tasks and game logic design. 🔍 Key Takeaways: Efficient grid representation simplifies complex visual problems. Direction-based iteration is a powerful technique for 2D traversal. Managing boundary conditions is essential in simulation-based coding problems. 🧠 Concepts Practiced: Grid traversal | Simulation | Matrix manipulation | Directional logic #LeetCode #150DaysOfCode #Day143 #CodingChallenge #LearnByDoing #ProblemSolving #Java #DSA #GridTraversal #Simulation #CodeEveryday

🚀 LeetCode POTD — 2536. Increment Submatrices by One 🎯 Difficulty: Medium | Topics: 2D Difference Array, Prefix Sums, Matrix Manipulation 🔗 Solution Link: https://lnkd.in/gpjg6t5w Today’s #LeetCode Problem of the Day was a classic 2D difference array question — simple once you recognize the pattern, but extremely efficient compared to brute-force updates. We’re given an n × n zero matrix and multiple queries, where each query asks us to increment every element in a submatrix by 1. Updating each cell one-by-one would be too slow, so difference-array logic makes the solution clean and optimal. 🧠 My Approach: For each query [x, y, a, b], instead of updating the entire submatrix, update only the start and end boundaries using difference marks: matrix[i][y] += 1; if (b + 1 < n) matrix[i][b + 1] -= 1; Loop from row x to a and apply these boundary updates. After processing all queries, run a prefix sum row-wise to build the final matrix. This reduces the complexity drastically and leverages the power of prefix operations. 📈 Complexity: Time: O(n² + q × submatrix_height) Space: O(n²) 💡 Takeaway: Difference arrays (1D or 2D) are among the most elegant techniques to convert repeated updates into boundary operations — a pattern that appears often in competitive programming and system-level problems. #LeetCode #ProblemOfTheDay #DSA #Matrix #PrefixSum #DifferenceArray #CodingChallenge #Programming #SoftwareEngineering #CodingJourney #100DaysOfCode #TechCommunity

✅ Day 4 of 50 Days Coding Challenge Problem: Product of Array Except Self Difficulty: Medium 🔍 What’s the challenge? Given an integer array nums, return an array answer such that answer[i] equals the product of all elements in nums except nums[i]. Constraints: Must run in O(n) time No division operation allowed 💡 My Approach: I used a two-pass prefix-suffix multiplication technique because: Division is not allowed, so we can’t simply compute the total product and divide. We need an efficient solution in O(n) without extra space (apart from the output array). Steps: 1. Initialize answer with 1s. 2. Traverse from left to right, storing cumulative product of elements before i (prefix). 3. Traverse from right to left, multiplying cumulative product of elements after i (suffix). 4. This way, each answer[i] = (product of all elements to the left) × (product of all elements to the right). ✅ Time Complexity: O(n) ✅ Space Complexity: O(1) (excluding output array) 📌 Why i used this method? 1. It avoids division, which is a constraint. 2. It’s memory-efficient and scales well for large arrays. 3. It’s a clean and intuitive approach using prefix and suffix products. When division is restricted, prefix-suffix multiplication is a powerful pattern for array problems. #LeetCode #CodingChallenge #CSharp #ProblemSolving #Day4 #DataStructuresAndAlgorithms #50DaysCodingchallenge

🧩 Day 64 of #100DaysOfCode 🧩 🔹 Problem: Remove All Adjacent Duplicates in String – LeetCode ✨ Approach: Used a stack-based approach to efficiently remove adjacent duplicates. For each character, if it matches the stack’s top element, pop it — otherwise, push it. A simple yet powerful way to process strings in O(n) time while maintaining clean logic. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — each character is processed once Space Complexity: O(n) — for the stack and output string ✅ Runtime: 23 ms (Beats 54.52%) ✅ Memory: 45.26 MB (Beats 85.43%) 🔑 Key Insight: Sometimes, solving problems isn’t about brute force — it’s about using the right data structure to make every step count. 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Stack #StringManipulation #CleanCode #CodingChallenge #AlgorithmDesign #LogicBuilding #CodeJourney #Programming

🎯 LeetCode Daily – Triangle (Day 113) Today’s problem deepened my understanding of Dynamic Programming on Triangular Grids, focusing on minimizing path sums efficiently. ✅ My Approach: 🔹 Problem – Triangle: • The goal was to find the minimum path sum from the top to the bottom of a triangle array. • Used Memoization (Top-Down DP) to recursively explore all paths while storing intermediate results to avoid redundant computations. • Implemented Tabulation (Bottom-Up DP) to build the solution iteratively starting from the last row and moving upward, computing the minimum path for each position using values from the row below. 🧠 Key Insight: This problem beautifully demonstrates the power of Dynamic Programming in optimizing recursive solutions. By transitioning from memoization to tabulation, the problem transforms from exponential recursion to an elegant linear-time solution. Recognizing overlapping subproblems and optimal substructure patterns is key to mastering DP on grids and triangles. 📊 Time Complexity: O(N²) 📦 Space Complexity: O(N²) #LeetCode #DSA #DynamicProgramming #ProblemSolving #DailyCoding #LearningInPublic #Day113

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