Decoding Slanted Ciphertext with Matrix Traversal

🚀 Day 71 of #100DaysOfCode Today, I solved LeetCode 1572 – Matrix Diagonal Sum, a problem that focuses on matrix traversal and efficient computation. 💡 Problem Overview: Given a square matrix, the task is to calculate the sum of its primary and secondary diagonals, ensuring that the center element (if overlapping) is counted only once. 🧠 Approach: ✔️ Traversed the matrix to calculate: Primary diagonal → elements where row == column Secondary diagonal → elements where row + column == n - 1 ✔️ Handled the center element separately to avoid double counting ⚡ Key Takeaways: Understanding index relationships simplifies matrix problems Edge cases (like overlapping elements) are important Clean logic can avoid unnecessary loops 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) Small problems strengthen big concepts 🚀 #LeetCode #100DaysOfCode #DSA #Matrix #ProblemSolving #CodingJourney #SoftwareDevelopment

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

🚀 LeetCode Update: “Sort Colors” Problem Solved! I recently solved the **Sort Colors** problem and got it accepted ✅ (89/89 test cases passed). Here’s a quick breakdown of my approach 👇 🧠 Problem Insight • The array contains only 0s, 1s, and 2s • Goal: sort them in-place without using extra space ⚙️ Approach Used: Dutch National Flag Algorithm • Maintained three pointers: low, mid, high • Divided the array into three regions: * 0s → left side * 1s → middle * 2s → right side • Traversed the array once and swapped elements accordingly 📈 Time & Space Complexity • Time Complexity: O(n) • Space Complexity: O(1) (in-place sorting) 💡 Key Learning • Efficient use of pointers can eliminate the need for extra space • Classic problems often have optimal patterns worth mastering 🔥 Always exciting to see how a simple-looking problem can teach powerful concepts! #LeetCode #DSA #CodingJourney #Cpp #ProblemSolving

🚀 Day 76 of #100DaysOfCode Today, I solved LeetCode 18 – 4Sum, a classic problem that extends the two-pointer technique to higher complexity. 💡 Problem Overview: Given an array, the task is to find all unique quadruplets that sum up to a target value. 🧠 Approach: ✔️ Sorted the array to simplify processing ✔️ Fixed two elements using nested loops ✔️ Applied the two-pointer technique for the remaining two elements ✔️ Carefully handled duplicates to ensure unique quadruplets This approach efficiently reduces unnecessary computations compared to brute force. ⚡ Key Takeaways: Sorting + Two Pointers is a powerful combination Avoiding duplicates is crucial in combination problems Breaking a complex problem into smaller parts simplifies logic 📊 Complexity Analysis: Time Complexity: O(n³) Space Complexity: O(1) (excluding output) Consistently pushing boundaries and solving more complex problems 🚀 #LeetCode #100DaysOfCode #DSA #TwoPointers #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

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

🚀 LeetCode 219 — Contains Duplicate II | Solved ✅ Today I tackled a classic Sliding Window + Hashing problem. 🔍 Problem: Check if there exist two equal elements such that their index difference is at most k. 💡 Approach: Used a sliding window of size k with a hash set to track elements. If an element already exists in the window → duplicate found. ⚡ Complexity: Time: O(n) Space: O(k) ✨ Key Learning: Instead of tracking frequency, sometimes just tracking presence is enough — simplifying both logic and performance. Consistency is the real key 🔑 #LeetCode #DSA #CodingJourney #SlidingWindow #Hashing