Optimize 3Sum from O(n³) to O(n²) with Sorting and Two Pointers

🚀 Solved another problem on LeetCode: Matrix Block Sum (2D Array Running Sum) Today I implemented a solution to compute the block sum for every element in a matrix. The task is to calculate the sum of all elements within a K-distance block around each cell while handling matrix boundaries correctly. My approach: I used a brute-force method where, for each element, I determine the valid block boundaries using max() and min() to avoid index overflow. Then I iterate through that block and accumulate the values. Key concepts used: • 2D array traversal • Boundary handling in matrices • Nested iteration over submatrices This problem strengthened my understanding of matrix manipulation and coordinate boundary control. It also highlights how prefix sums can further optimize the solution for larger inputs. LeetCode practice continues! 💻📊 #LeetCode #DataStructures #Algorithms #Python #CodingPractice #ProblemSolving

Today I solved Majority Element, a fundamental problem that highlights efficient array processing and algorithmic thinking. 🔹 Problem: Given an array nums of size n, return the majority element. The majority element is the element that appears more than ⌊n/2⌋ times in the array. 🔹 Approach (Boyer–Moore Voting Algorithm): Instead of counting frequencies with extra space, we can use an elegant algorithm that works in O(n) time and O(1) space. Steps: Maintain a candidate and a count. If the count becomes 0, select the current number as the new candidate. Increase count if the element matches the candidate, otherwise decrease it. 🔹 Example: Input: [2,2,1,1,1,2,2] Output: 2 🔹 Complexity: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💡 This problem is a great example of how clever algorithms can eliminate the need for extra memory while maintaining efficiency. #LeetCode #Algorithms #DataStructures #Python #CodingPractice #ProblemSolving #BoyerMoore #SoftwareEngineering

🚀 Day 55 of #100DaysOfCode Solved LeetCode 350 – Intersection of Two Arrays II today! 🔍 Problem Insight: Given two arrays, we need to return their intersection such that each element appears as many times as it occurs in both arrays. 💡 Approach Used: - Used "Counter" (hash map) to store frequency of elements from first array - Traversed second array and matched elements - Reduced count after every match to handle duplicates correctly ⚡ Why this works: Efficient frequency tracking avoids nested loops and reduces time complexity. 🧠 Complexity: - Time: O(n + m) - Space: O(n) ✅ Key Learning: Hashing + frequency counting is powerful for problems involving duplicates and intersections. 🔥 Consistency is the key — showing up every day! #DSA #LeetCode #Python #CodingJourney #PlacementPrep #SoftwareEngineering #100DaysOfCode

Merge Intervals (LeetCode 56) - Medium Key Learnings: Sorting: By sorting intervals based on their start times, we can process them in a single pass (O(N)). Overlap Logic: Comparing the current_start with the previous_end time is the secret sauce to identifying overlaps. Space-Time Tradeoff: Sorting takes O(N log N) time, and we use O(N) space to store the results. #CodingJourney #LeetCode #Blind75 #SDEPreparation #SoftwareEngineering #Python #DataStructures

Tree Diameter: When Return Value Differs from Global Optimization Most tree recursion returns the answer upward. Diameter breaks this — longest path might not include current node, so we can't compose from return values alone. Solution: track two separate values — height (returned for parent) and diameter (stored globally). Pattern: When local computation (diameter through node) differs from parent's need (height contribution), split concerns — return value for upward propagation, global state for cross-tree aggregation. Time: O(n) | Space: O(h) #TreeAlgorithms #GlobalState #DiameterProblem #RecursionPatterns #Python #AlgorithmDesign #SoftwareEngineering

From Guesswork to Evidence This week I open-sourced a small CLI tool: Activity Reporter. It scans a directory within a given time window and generates a human-readable report of file activity. But the real focus isn’t the feature. It’s the design principles behind it: • One-shot execution • Read-only • Append-only logs • No automatic judgment Most tools try to decide for you. I prefer tools that generate evidence and leave decisions to humans. To me, engineering is about reducing uncertainty — not adding abstraction. Repo link in the comments. #SoftwareEngineering #OpenSource #DevTools #Python #EngineeringMindset

Inorder Traversal: Left-Root-Right Yields Sorted BST Output Inorder (left → root → right) produces sorted output on BSTs — the defining property. Processing all smaller values (left), then current, then larger (right) naturally enforces ordering. This traversal-structure relationship is fundamental. Exploitable Property: Inorder's sorted output enables O(n) BST validation (check strict increasing), kth smallest (stop at kth), range queries. Choose traversal based on what property you need. Time: O(n) | Space: O(h) #InorderTraversal #BSTProperties #TreeAlgorithms #SortedOutput #Python #AlgorithmDesign #SoftwareEngineering

Watching an image reconstruct itself. 🛠️ Following up on my last post about sinograms—I finished the backprojection implementation in Python. It’s one thing to read that a CT image is "reconstructed" from projections; it’s another to watch it happen frame-by-frame. In the video: The Comparison: A side-by-side of the original digital phantom and my reconstructed result. The Process: The "streaks" of data from the sinogram being layered back over the canvas until the final anatomy emerges. The Technical Reality Check: The biggest challenge was the blur. Without applying a filter (like a Ramp filter) before backprojecting, the result is just a fuzzy "star" artifact. Coding the filter was the secret to getting the crisp edges you see in the comparison. This project turned a "dry" exam topic into a working tool. Now, I can actually see the math working. #MedicalImaging #Python #RadonTransform #Coding #STEM #CT

✅ Day 16 of #DSAPrep > Problem: Bubble Sort > Concept: Sorting Algorithm Implemented Bubble Sort by comparing adjacent elements and swapping them if they are in the wrong order. With each iteration, the largest element moves to its correct position at the end of the array. > Key Idea: - Compare adjacent elements - Swap if left element is greater than right - Repeat until the array is sorted > Time Complexity: O(n²) > Space Complexity: O(1) #DSAPrep #Algorithms #Python #Sorting #ProblemSolving #CodingJourney

Tree Diameter: Tracking Height and Max Path with Global State Longest path might not include current node, so can't compose answer from return values alone. Solution: return height for parent's calculation, track diameter globally. At each node, potential diameter through it = left_height + right_height. Dual-Purpose Recursion: When local computation differs from parent's need, split concerns — return for upward propagation, global state for aggregation. Pattern appears in weighted paths, subtree properties. Time: O(n) | Space: O(h) #TreeAlgorithms #GlobalState #DiameterProblem #DualPurposeRecursion #Python #AlgorithmDesign #SoftwareEngineering