LeetCode 1572 Matrix Diagonal Sum Solution

Day 88 of #100DaysOfCode Today I solved "Construct Binary Search Tree from Preorder Traversal" on LeetCode using Recursion + Range Validation. Key Idea: In preorder traversal, elements are processed as: Root → Left → Right We can rebuild the BST by maintaining a valid range (lower, upper) for each node. Approach: • Start with range (-∞, +∞) • Pick current value → create node • For left subtree → range becomes (lower, root value) • For right subtree → range becomes (root value, upper) • Move index forward while constructing tree This ensures we build a valid BST without searching Concepts Used: • Binary Search Tree (BST) • Recursion • Preorder Traversal • Range constraints Time Complexity: O(n) Space Complexity: O(h) This problem shows how powerful range-based recursion can be for tree construction Understanding traversal patterns is unlocking new levels #Day88 #100DaysOfCode #LeetCode #BST #Recursion #Cpp #CodingJourney

🚀 Day 66 of #100DaysOfCode Today, I solved LeetCode 73 – Set Matrix Zeroes, a classic problem that tests in-place matrix manipulation and optimization techniques. 💡 Problem Overview: Given a matrix, if any cell contains 0, its entire row and column must be set to 0. The challenge is to perform this efficiently without using excessive extra space. 🧠 Approach: To solve this optimally, I focused on: ✔️ Using the first row and first column as markers ✔️ Tracking whether the first row/column initially contained zero ✔️ Updating the matrix in-place based on these markers This avoids using additional space and achieves optimal performance. ⚡ Key Takeaways: In-place algorithms help reduce space complexity Using matrix itself as storage is a powerful optimization trick Handling edge cases (first row/column) is critical 📊 Complexity Analysis: Time Complexity: O(n × m) Space Complexity: O(1) Improving problem-solving skills one day at a time 🚀 #LeetCode #100DaysOfCode #DSA #Matrix #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

🚀 Day 62 of #100DaysOfCode Today, I solved LeetCode 2075 – Decode the Slanted Ciphertext, a problem that focuses on matrix traversal and string manipulation. 💡 Problem Overview: Given an encoded text written in a slanted manner across a matrix, the task is to reconstruct the original message by decoding it correctly. 🧠 Approach: To solve this problem efficiently, I focused on: ✔️ Constructing the matrix from the given encoded string ✔️ Traversing diagonally to extract the original message ✔️ Handling trailing spaces carefully to get the correct output This approach ensures accurate decoding while maintaining simplicity. ⚡ Key Takeaways: Matrix traversal techniques are useful in string problems Diagonal traversal patterns often appear in encoding/decoding tasks Edge case handling (like trailing spaces) is crucial 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) Consistency and structured practice are driving continuous improvement 🚀 #LeetCode #100DaysOfCode #DSA #Strings #MatrixTraversal #ProblemSolving #CodingJourney #SoftwareDevelopment

🚀 Day 70 of #100DaysOfCode Today, I solved LeetCode 1559 – Detect Cycles in 2D Grid, a problem that combines graph traversal with cycle detection in a matrix. 💡 Problem Overview: Given a 2D grid of characters, the task is to determine whether there exists a cycle formed by adjacent cells having the same value. 🧠 Approach: ✔️ Treated the grid as a graph where each cell is a node ✔️ Applied DFS/BFS to traverse connected components ✔️ Tracked the parent cell to detect cycles correctly ✔️ If a visited cell is encountered again (not the parent), a cycle exists ⚡ Key Takeaways: Cycle detection in grids requires careful parent tracking Matrix problems can be converted into graph problems DFS/BFS are versatile for both traversal and cycle detection 📊 Complexity Analysis: Time Complexity: O(n × m) Space Complexity: O(n × m) 70 days of consistency — building stronger problem-solving skills every day 🚀 #LeetCode #100DaysOfCode #DSA #Graphs #CycleDetection #DFS #BFS #ProblemSolving #CodingJourney #SoftwareDevelopment #Consistency

Day 5️⃣ /15 — Consistency Challenge 🚀 Today’s problem: LeetCode 1855 — Maximum Distance Between a Pair of Values Solved using a clean two-pointer approach. 🔹 Problem Idea: We need to find the maximum value of j - i such that: i <= j nums1[i] <= nums2[j] Both arrays are non-increasing (sorted in descending order), which makes this a perfect two-pointer problem. 🔹 Approach (Two Pointers): Start two pointers: i = 0 for nums1 j = 0 for nums2 Traverse while both pointers are in bounds: If nums1[i] <= nums2[j] ✅ Valid pair found Update answer with j - i Move j forward to try for a larger distance Else (nums1[i] > nums2[j]) ❌ Invalid pair Move i forward to reduce nums1[i] and try to make condition valid 🔹 Time Complexity: Each pointer moves at most once through its array 👉 O(n + m) 🔹 Space Complexity: 👉 O(1) Clean logic, efficient solution, and another step in the consistency journey 💯 #LeetCode #DSA #TwoPointers #Consistency #CodingJourney #LearnInPublic

Day 46 of #100DaysOfLeetCode Problem: Length of Last Word   Difficulty: Easy  Key Concept Learned: Reverse Traversal with Two Pointer Thinking  Today I solved the problem Length of Last Word. The task was to find the length of the last word in a given string. Instead of splitting the string, I used a more efficient approach by traversing from the end. First, I ignored all the trailing spaces. Then I counted the characters until I reached a space or the beginning of the string. This approach avoids extra space and keeps the solution simple and clean. Time Complexity: O(n)   Space Complexity: O(1)  Key Takeaways Traversing from the end can simplify string problems  Avoiding extra operations like split can make solutions more efficient  Handling edge cases like trailing spaces is important  Simple logic often leads to optimal solutions  Consistency is helping me improve step by step  #100DaysOfLeetCode #DSA #LeetCode #CodingJourney #ProblemSolving

📅 Day 269 – Recursive Pattern Generation (Apr 2, 2026) 🔢🔁 🔹 Problems Solved Today: 1️⃣ LeetCode 38 – Count and Say 🔢 • Built the sequence iteratively from previous term. • Counted consecutive digits and formed the next string. • Repeated process until reaching the nth term. • Used two-pointer / run-length encoding style logic. • Reinforced pattern generation and string construction. 💡 Key Takeaways from Day 269: • Many sequence problems are based on previous state transformation. • Run-length encoding is a powerful pattern for grouping characters. • Iterative building is often simpler than recursion here. 🔥 Consistency Update: ✅ Day 269 streak maintained. 🎯 1006 problems solved so far. #LeetCode #DSA #ProblemSolving #Strings #Simulation #Consistency #Day269 🚀

🚀 Day 79 of #100DaysOfCode Today, I solved LeetCode 32 – Longest Valid Parentheses, a challenging problem that focuses on stack-based logic and string processing. 💡 Problem Overview: Given a string containing only '(' and ')', the goal is to find the length of the longest valid (well-formed) parentheses substring. 🧠 Approach: ✔️ Used a stack-based approach to track indices ✔️ Initialized stack with -1 to handle edge cases ✔️ For every closing bracket, popped from stack ✔️ Calculated valid substring length using current index and stack top This approach efficiently tracks valid sequences and avoids reprocessing. ⚡ Key Takeaways: Stack is powerful for handling matching problems Index-based tracking simplifies substring calculations Handling edge cases (like invalid starting brackets) is crucial 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) Solving hard problems step by step and improving every day 🚀 #LeetCode #100DaysOfCode #DSA #Stack #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep #HardProblems

🚀 Day 30/50 – LeetCode Challenge 🧩 Problem #8 – String to Integer (atoi) Today’s problem focused on converting a string into an integer while handling multiple edge cases, making it a great exercise in string parsing and validation. 📌 Problem Summary: Implement the atoi function that converts a string into a 32-bit signed integer. The function must: ✔ Ignore leading whitespaces ✔ Handle optional + or - sign ✔ Read digits until a non-digit character appears ✔ Clamp the result within the 32-bit integer range 🔍 Approach Used ✔ Removed leading spaces using strip() ✔ Checked for sign (+ or -) ✔ Iterated through characters and built the number ✔ Stopped when a non-digit character appeared ✔ Handled overflow by restricting values to valid integer range ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💡 Key Learning ✔ Handling multiple edge cases carefully ✔ Understanding string parsing logic ✔ Managing integer overflow conditions ✔ Writing clean and robust code This problem shows how important it is to handle real-world input scenarios properly. Consistency builds strong problem-solving skills 🚀 🔗 Problem Link: https://lnkd.in/g-Df-jxW #50DaysOfLeetCode #LeetCode #DSA #Strings #ProblemSolving #CodingJourney #FutureAIEngineer #Consistency

Day 86 of #100DaysOfCode Today I solved "Kth Smallest Element in a BST" on LeetCode using an Iterative Inorder Traversal (Stack). Key Idea: In a Binary Search Tree (BST), inorder traversal gives elements in sorted order. So the kth smallest element is simply the kth element in inorder traversal. Approach: • Use a stack to simulate inorder traversal • Traverse to the leftmost node first • Pop nodes one by one and decrement k • When k == 0, we’ve found our answer Concepts Used: • Binary Search Tree (BST) • Inorder Traversal • Stack • Iterative approach Time Complexity: O(h + k) Space Complexity: O(h) This problem shows how we can convert recursive traversal into an efficient iterative solution using a stack Understanding BST properties is really paying off now #Day86 #100DaysOfCode #LeetCode #BST #Stack #Cpp #CodingJourney