Optimize Histogram Rectangle Finding with Monotonic Stack

✅ Day 83 of 100 Days LeetCode Challenge Problem: 🔹 #832 – Flipping an Image 🔗 https://lnkd.in/ghfEcHHT Learning Journey: 🔹 Today’s problem involved two operations on a binary matrix: horizontal flip and bit inversion. 🔹 First, I reversed each row to achieve the horizontal flip. 🔹 Then, I inverted every bit (0 → 1 and 1 → 0) using a helper function. 🔹 This approach ensured the transformation was done in-place without extra space. Concepts Used: 🔹 Array Manipulation 🔹 Matrix Traversal 🔹 Two-Pointer / In-place Operations 🔹 Bit Manipulation Key Insight: 🔹 Instead of treating flipping and inversion as separate heavy operations, they can be efficiently combined or done sequentially in-place. 🔹 Using simple transformations keeps the solution clean and optimal. Complexity: 🔹 Time: O(n × m) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

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

🚀 Stop iterating through rows like it’s 2010. In a recent pipeline, we were processing 5 million records to calculate a rolling score. Using a standard loop took forever and pegged the CPU at 100%. Before optimisation: for i in range(len(df)): df.at[i, 'score'] = df.at[i, 'val'] * 1.05 if df.at[i, 'flag'] else df.at[i, 'val'] After optimisation: import numpy as np df['score'] = np.where(df['flag'], df['val'] * 1.05, df['val']) Performance gain: 85x faster execution. Vectorisation isn’t just a "nice to have"—it’s the difference between a pipeline that crashes at 2 AM and one that finishes in seconds. By letting NumPy handle the heavy lifting in C, we eliminated the Python overhead entirely. If you're still using `.iterrows()` or manual loops for column transformations, it’s time to refactor. The performance delta on large datasets is simply too massive to ignore. What is the biggest "bottleneck" function you’ve refactored recently that gave you a massive speedup? #DataEngineering #Python #PerformanceTuning #Vectorization #DataScience

✅ Day 78 of 100 Days LeetCode Challenge Problem: 🔹 #3110 – Score of a String 🔗 https://lnkd.in/g9jgxcdK Learning Journey: 🔹 Today’s problem involved calculating the score of a string based on the absolute differences between ASCII values of adjacent characters. 🔹 I iterated through the string starting from index 1 and computed the difference between the current and previous character using ord(). 🔹 For each pair, I added the absolute difference to a running total. 🔹 This approach efficiently accumulates the score in a single pass. Concepts Used: 🔹 String Traversal 🔹 ASCII Value Conversion (ord()) 🔹 Absolute Difference Calculation Key Insight: 🔹 The problem reduces to comparing adjacent elements, making it a straightforward linear scan. 🔹 Using ord() allows direct access to ASCII values, simplifying the computation. Complexity: 🔹 Time: O(n) 🔹 Space: O(1) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

✅ Day 65 of 100 Days LeetCode Challenge Problem: 🔹 #394 – Decode String 🔗 https://lnkd.in/gD2KzChY Learning Journey: 🔹 Today’s problem involved decoding encoded strings with the pattern k[encoded_string]. 🔹 The key challenge was handling nested encodings, where brackets can appear inside other brackets. 🔹 I used a stack to store the current string and repeat count whenever a [ appears. 🔹 When encountering ], I popped the previous state and expanded the current substring accordingly. Concepts Used: 🔹 Stack Data Structure 🔹 String Manipulation 🔹 Parsing Nested Structures 🔹 Simulation Key Insight: 🔹 Each [ marks the start of a new decoding context, which can be stored in a stack. 🔹 When ] appears, the substring is repeated k times and merged with the previous context. 🔹 This approach handles nested patterns cleanly with a single linear pass. Complexity: 🔹 Time: O(n) 🔹 Space: O(n) #LeetCode #Algorithms #DataStructures #CodingInterview #100DaysOfCode #SoftwareEngineering #Python #ProblemSolving #LearningInPublic #TechCareers

Binary Search on Rotated Arrays: Adapting Logarithmic Search to Broken Invariants Standard binary search requires sorted data. When an array is rotated (e.g., [4,5,6,7,0,1,2]), the sorted property breaks globally but persists locally — one half is always properly sorted. The adaptation: determine which half is sorted by comparing endpoints, then check if the target falls within that sorted range. This preserves O(log n) complexity despite the rotation disrupting global order. The Design Lesson: When invariants break, look for partial invariants. Here, global sorting is lost but local sorting remains. This "find the preserved property" approach applies broadly — searching in nearly-sorted data, handling corrupted indices with known structure, or working with time-series data with periodic gaps. The algorithm adapts to what guarantees still hold. Time: O(log n) | Space: O(1) #BinarySearch #AdaptiveAlgorithms #RotatedArrays #InvariantPreservation #Python #AlgorithmDesign #SoftwareEngineering

Why Sorting Changes Everything: Two Sum in O(1) Space The classic Two Sum problem typically requires a HashMap for O(n) time and O(n) space. But when the input is already sorted, a completely different approach emerges: two pointers converging from opposite ends. The key insight: if the current sum is too large, the right pointer must move left (smaller values); if too small, the left pointer must move right (larger values). This eliminates the need for any auxiliary data structure. The Real Lesson: Data properties unlock different algorithmic approaches. Sorted data enables two-pointer techniques, eliminating space overhead. This same principle applies across domains — leveraging pre-existing order (timestamps in logs, sorted database indices) can transform O(n) space solutions into O(1) space with the same time complexity. Time: O(n) | Space: O(1) #AlgorithmOptimization #TwoPointers #SortedArrays #SpaceComplexity #Python #CodingInterview #SoftwareEngineering

I recently worked on a project focused on optimizing pathfinding algorithms — and it gave me a deeper appreciation for how efficient systems are built. 🚀 Project: Pathfinding Algorithm Optimization 🔧 What I did: • Built a route optimization tool using Dijkstra’s and A* algorithms • Modeled real-world road networks using geospatial data • Used Python with OSMnx and NetworkX to simulate city navigation 📊 Results: Improved traversal efficiency by ~65% by applying heuristic-based optimizations. 📍 What I learned: • How algorithms behave in real-world scenarios (not just theory) • The impact of heuristics on performance • How to visualize complex data to make it understandable One thing that stood out — small optimizations can lead to significant performance gains when working with large-scale systems. Still exploring and improving my understanding of algorithms and backend systems. Would love to hear your thoughts or feedback! #SoftwareEngineering #Python #Algorithms #DataStructures #LearningInPublic #TechProjects

I just dropped a new video breaking down my Personal Assistant project. In 6 minutes I walk through the full system — architecture, code, RAG memory layer, and a live demo. If you're into Python, FastAPI, or AI automation, this one's for you. 👉 https://lnkd.in/dtKqdMiM #Python #FastAPI #AI #RAG #BuildInPublic

🚀 Day 9 – DSA Daily Series Today’s Problem: Merge Sorted Array (LeetCode 88) Today I solved an interesting problem that involves merging two sorted arrays efficiently. 🧠 Problem You are given two sorted arrays nums1 and nums2. nums1 has enough extra space at the end to hold elements from nums2. The goal is to merge both arrays into a single sorted array inside nums1. Example: Input: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,5,6], n = 3 Output: [1,2,2,3,5,6] 💡 Approach Instead of creating a new array, I solved this using the two-pointer technique from the end. Steps followed: • Start pointers from the end of both arrays • Compare the elements from nums1 and nums2 • Place the larger element at the end of nums1 • Move the pointers accordingly until all elements are merged This approach avoids unnecessary shifting of elements. ⏱ Complexity Time Complexity: O(m + n) Space Complexity: O(1) 🔎 Key Learning Working from the end of the array is a smart trick that helps avoid overwriting elements while merging. Continuing the DSA Daily Series — improving problem-solving skills one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #CodingJourney #ProblemSolving