Solved LeetCode problem 54: Spiral Matrix traversal in Python

Day 13 of #100DaysOfLeetCode Problem: 88. Merge Sorted Array Category: Arrays / Sorting / Two Pointers Today’s challenge focused on merging two sorted arrays into one, maintaining the sorted order. It’s a simple yet powerful problem that tests your understanding of array indices, merging logic, and in-place updates. 🧠 Key Learnings: Extended the first array by adding elements from the second, then sorted the combined list. Reinforced the importance of efficient merging techniques for sorted sequences. Understood how in-place operations can reduce memory usage in practical scenarios. Strengthened logic building around sorting fundamentals and index-based insertion. 🎯 Takeaway: Even simple array problems help build strong fundamentals in sorting and data manipulation — the key to mastering larger algorithmic challenges. #LeetCode #100DaysOfCode #ProblemSolving #CodingJourney #Arrays #Sorting #Python #AIEngineer #Consistency

🚀 Day 3 of #100DaysofDSA Today’s focus was on the “Set Matrix Zeroes” problem — a classic array-matrix question that tests both logic and optimization thinking It began with the brute-force idea: storing all zero positions and then marking corresponding rows and columns later. It works but takes O(m × n) time and O(m + n) extra space. Next, then explored a better approach using two auxiliary arrays to track which rows and columns should be zeroed. This improved the clarity but still consumed additional memory and space. Finally, then to reduce the complexity I tackled the optimal solution, which achieves O(1) extra space by using the first row and first column of the matrix itself as markers. A small Boolean flag handles the edge case when the first row contains a zero. This subtle observation transforms the logic completely — turning a memory-heavy method into a clean in-place algorithm. It was a good reminder that optimization isn’t just about speed — it’s about finding elegance in constraints. #100DaysOfDSA #MatrixProblems #Optimization #SpaceComplexity #Python #ProblemSolving

✅ Learned to solve “Remove Duplicates from Sorted Array” (in-place, O(n) time, O(1) space)! Sorted input means every duplicate sits next to its twin—perfect setup for the two-pointer pattern: scan once, write uniques forward, and return the count k while keeping the first k positions clean and ordered. What clicked: - Two pointers: one scans, one writes uniques forward - Skip repeats deterministically thanks to sorting - Edge cases covered: empty array, all duplicates, negatives, mixed ranges Level-ups next: “Remove Duplicates II” (allow at most twice) and “Remove Element” to deepen the pattern muscle. What’s your favorite twist on this technique? 🚀 #LeetCode #TwoPointers #Arrays #InPlace #DSA #Algorithms #InterviewPrep #ProblemSolving #TimeComplexity #CodingChallenge #Python #SoftwareEngineering

✅ LeetCode 3446 – Sort Matrix by Diagonals Successfully solved another interesting matrix manipulation problem! 🧩 Problem Summary: Given an n × n matrix, the task is to sort: The bottom-left diagonals (including the main diagonal) in non-increasing order. The top-right diagonals in non-decreasing order. 💡 Approach: Use a dictionary to group elements by diagonal index (j - i). Sort each diagonal individually based on its position (top or bottom triangle). Reconstruct the matrix by placing back the sorted values. ⚙️ Key Concepts: Matrix traversal Diagonal indexing (j - i) Sorting and reconstruction 📊 Result: ✅ Accepted with 0 ms runtime 💪 Optimized, clean, and easy-to-read solution #LeetCode #Python #ProblemSolving #CodingChallenge #DataStructures #Algorithms #Matrix #DeveloperJourney

Day 16 of #100DaysOfLeetCode Today’s problem focused on substring counting within binary strings and required an efficient approach to handle potentially large input sizes without generating every substring explicitly. 1. Number of Substrings With Only 1s The task was to count the total number of substrings that consist entirely of the character '1', with the final result taken modulo (10^9 + 7). Instead of constructing the substrings, the key insight is that each continuous block of 1s contributes a predictable number of valid substrings. 🔹 My Approach: Iterated through the string while tracking the current streak length of consecutive 1s. Each time a block ended, computed the number of substrings from that block using the formula: k*(k+1)/2 where k is the length of the streak. Added the total from each block to the final answer, applying the modulo constraint throughout. Completed the process with a final update for any trailing block of 1s. What I Learned: This problem reinforces how recognizing mathematical patterns within sequences can transform a brute-force solution into a simple linear scan. Efficient substring counting often comes down to understanding structure rather than enumerating possibilities. 📊 Complexity Analysis: Time Complexity: O(n) — single pass over the string. Space Complexity: O(1) — constant space approach. #day16 #100daysofleetcode #leetcode #DSA #python #leetcodes #striver

🧩 Day 45 — Remove Duplicates from Sorted Array II (LeetCode 80) 📝 Problem Given an integer array nums sorted in non-decreasing order, remove some duplicates in-place such that each unique element appears at most twice. The relative order of the elements should be kept the same. Return the number of valid elements remaining after modification. 🔁 Approach -Use the two-pointer technique to modify the array in-place. -If the array length ≤ 2, return its length (since all are valid). -Start checking from index 2 because the first two elements can always stay. -For each element, compare it with the element two positions before. -If they differ, keep the current element; otherwise, skip it. -The count of valid elements represents the final result. 📊 Complexity -Time Complexity: O(n) -Space Complexity: O(1) 🔑 Concepts Practiced -Two-pointer technique -In-place array modification -Working with sorted arrays #Leetcode #Sorting #DSA #Python

Day 3 of #100DaysOfLeetCode Problem: 167. Two Sum II – Input Array Is Sorted Category: Arrays / Two Pointers Today’s challenge was all about finding two numbers in a sorted array that add up to a given target. Since the array is already sorted, using two pointers gives an elegant O(n) solution — no need for extra space! 🧠 Key Learnings: Initialized pointers at both ends (l = 0, r = n-1). If the sum is smaller than the target → move left pointer rightward. If the sum is greater → move right pointer leftward. Found the exact indices in linear time using smart pointer movement. 💡Time Complexity: O(n) 💡 Space Complexity: O(1) 🎯 Takeaway: When the array is sorted, two pointers can replace complex hash-based logic, simplifying both time and space usage. Staying consistent and learning one problem at a time! 💪 #LeetCode #100DaysOfCode #ProblemSolving #CodingJourney #Arrays #TwoPointers #Python #AIEngineer #Consistency

Day 14 of #30DaysOfCode with Educative 🟦 Challenge: Binary Tree Zigzag Level Order Traversal Approach: Breadth-first search (BFS) with a direction toggle. Insight: Use BFS to collect nodes level by level, toggling a boolean to decide whether to reverse the collected list for zigzag behavior. Reflection: Implementing zigzag level order traversal shows how simple toggling logic combined with BFS can solve problems that mirror real-world requirements—like managing alternating workflows or data processing sequences in backend systems. #Educative #Python #SoftwareEngineering #ContinuousLearning #ProblemSolving

Day 11 of #100DaysOfLeetCode Problem: 14. Longest Common Prefix Category: Strings / Comparison / Iteration Today’s challenge focused on finding the longest common prefix among an array of strings. It’s a great problem that improves your understanding of string traversal, comparison, and boundary conditions. 🧠 Key Learnings: Iterated character by character through the first string and compared it with all other strings. Carefully handled edge cases where strings had different lengths or no common prefix. Reinforced the concept of early termination when a mismatch is found — improving efficiency. Strengthened skills in iterative string comparison and control flow logic. 🎯 Takeaway: Small details like string length and early exit conditions make a big difference in optimizing even the simplest problems. #LeetCode #100DaysOfCode #ProblemSolving #CodingJourney #Strings #Python #AIEngineer #Consistency

Day 8 of #100DaysOfLeetCode Problem: 9. Palindrome Number Category: Math / Two Pointers / Logic Today’s problem focused on determining whether an integer reads the same backward as forward — essentially checking if a number is a palindrome. 🧠 Key Learnings: Reversed the number mathematically using modulo and integer division. Avoided converting integers to strings, focusing purely on arithmetic logic. Understood how to handle special cases like negative numbers and numbers ending with zero. Strengthened my skills in digit manipulation and loop-based reversal logic. 🎯 Takeaway: Sometimes, avoiding built-in functions helps build a deeper understanding of fundamental logic — every digit and operation counts! #LeetCode #100DaysOfCode #ProblemSolving #CodingJourney #Math #LogicBuilding #Python #AIEngineer #Consistency