Minimize Score Difference with Sliding Window Sorting

Ever wonder how to minimize costs when equalizing tower heights? Here is a breakdown of the optimal approach for the Equalize the Towers problem. The Goal: Make all towers the same height by adding or removing blocks. Each tower has a unique cost per unit of change, and we need to find the specific height that results in the lowest total expenditure. The Approach: The total cost function here is convex, meaning if you were to graph the cost against all possible target heights, it would form a clear U-shape. This mathematical property allows us to find the minimum without checking every single height. Ternary Search Strategy: Instead of a linear search, we use Ternary Search. We divide our range of possible heights into three segments. By comparing the costs at two internal midpoints, we can determine which third of the range the minimum cost cannot be in and discard it. Efficiency: While a brute-force search would be slow, Ternary Search cuts the search space down exponentially. This results in a time complexity of O(N * log(MaxHeight)), making it highly efficient for large datasets. Check out the clean Python implementation here: https://htmlify.me/r/h0ks #Algorithms #DataStructures #Python #Coding #GeeksforGeeks #Optimization

I recently tackled an interesting sliding window problem: given a binary array, what is the maximum number of consecutive 1's you can get if you are allowed to flip at most k zeros? The Logic: Instead of trying every possible flip (which would be O(n^2) or worse), I used the Sliding Window (Two Pointers) technique. ✅ Expand: Move the right pointer to grow the window. ✅ Constraint Check: If we hit more than 'k' zeros, it's time to shrink the window from the left. ✅ Maximize: Keep track of the largest window size we've seen that satisfies the condition. Efficiency: By only passing through the array once, the solution hits an optimal O(n) time complexity and O(1) space complexity. It’s a classic example of how a dynamic window can turn a complex search into a streamlined linear process. Implementation: https://htmlify.me/r/6uhp #DataStructures #Algorithms #Python #CodingChallenge #SlidingWindow #ProblemSolving

🚀 Gradient Descent from Scratch – Learning by Building Batch vs. Stochastic vs. Mini-Batch. 📉 No Scikit-Learn, no PyTorch—just pure Python and math. I implemented all three variants to really understand how they converge: ⏺️Batch Gradient Descent: Great for stable convergence, but computationally heavy on large datasets. ⏺️Stochastic Gradient Descent (SGD): Faster and handles redundancy well, but the convergence path is... noisy. ⏺️Mini-Batch Gradient Descent: The sweet spot. Balances the stability of Batch with the speed of SGD. Building these from the ground up gave me a much deeper appreciation for what happens when we call .fit(). Check out the repo below if you're interested in the math behind the magic! 👇 https://lnkd.in/gDUM8vE5 #MachineLearning #DeepLearning #Python #DataScience #CodingFromScratch

🚀 Day 54 of #100DaysOfMachineLearning: Cracking the Matrix Code of Linear Regression! When you move from 1 feature to n features, simple algebra stops working. You need the power of Linear Algebra. Today, I derived the mathematical engine behind Multiple Linear Regression: The Normal Equation. The Formula: β=(XTX)−1XTY It looks intimidating, but it's elegant: - XTX: Captures the spread and relationship between features. - Inverse: Like dividing by the variance (normalizing). - XTY: Captures the relationship between features and the target. The Implementation: I coded a custom class MeraLR from scratch using Python and Numpy. Using just one line of code for the formula, my model predicted values identical to Scikit-Learn’s production-ready model. Takeaway: Scikit-Learn isn't magic; it's just math optimized for code. Understanding the (X.T @ X).inv logic makes you appreciate the library even more. Next challenge: What happens when the dataset is too big to invert? Enter Gradient Descent! 📉 #MachineLearning #DataScience #LinearAlgebra #Python #Coding #Mathematics #100DaysOfML #CampusX

#week -2 Topic : Arrays - DSA Array : An array is used to store a collection of elements under a single variable ,instead of storing the data indifferent variables which saves the memory. let us discuss some array operations : 1) #max and min num in an array def find_max_min(arr): if not arr: return none max_val=arr[0] min_val=arr[0] for num in arr: if num>max_val: max_val=num if num<min_val: min_val=num return max_val, min_val arr=[1, 6,7,0,4] print(find_max_min(arr) ) 2) #sum of elements arr = [1, 2, 3, 4, 5] total = 0 for num in arr: total += num print(total) def reverse_array(arr): start = 0 end = len(arr) - 1 while start < end: arr[start], arr[end] = arr[end], arr[start] start += 1 end -= 1 return arr arr = [1, 2, 3, 4, 5] print(reverse_array(arr)) #DSA #python #arrays #learning

I just tackled the Max Sum in Configuration problem! Instead of using a brute-force O(n^2) approach by rotating the array manually, I used a mathematical observation to solve it in O(n) time with O(1) space. The Approach: 1. Calculate the total sum of all elements and the initial weighted sum (index * value). 2. Observe the pattern: when we rotate the array, the change in the weighted sum follows a specific relation. 3. By deriving the formula Next_Sum = Current_Sum + Total_Sum - (n * last_element), we can calculate the sum of any rotation in constant time. 4. Iterate through all possible rotations and keep track of the maximum value. This optimization significantly improves performance for larger datasets. Implementation: https://htmlify.me/r/dj87 #Algorithm #Python #DataStructures #CodingLife #Optimization

Efficiency matters 🚀 The Sliding Window Maximum is a classic problem where a brute-force approach often fails. To get it down to linear time, we use a Monotonic Deque. The Logic: 🔹 Keep it fresh: Remove indices from the front once they fall out of the window range. 🔹 Stay Monotonic: Before adding a new value, pop smaller values from the back. They will never be the maximum if a newer, larger value is present. 🔹 Peak Performance: The maximum for the current window is always sitting at the front of your deque. The Result: Every element is processed at most twice (one push, one pop), making the algorithm O(n) and incredibly fast for large-scale data.' Implementation: https://htmlify.me/r/5o63 #Algorithms #Python #CodingTips #DataStructures

Day 3 of #200DaysOfCode! 🚀 Today, I leveled up from finding pairs to finding triplets with the classic "3Sum" problem (LeetCode 15). The goal is to find all unique triplets in an array that sum up to zero. The naive approach (three nested loops) is a painfully slow O(N^3). To solve this efficiently, I had to combine sorting with the Two Pointer technique. My O(N^2) Approach: Sort First: I started by sorting the array. This is crucial because it allows us to use pointers effectively and easily handle duplicates. Fix One, Solve Two: I iterated through the array with a fixed pointer i. For each number, the problem reduces to finding two other numbers that sum to -nums[i]. The "Two Pointer" Sweep: I placed a left pointer at i+1 and a right pointer at the end. If the sum is too small, move left forward. If the sum is too big, move right backward. The Tricky Part (Duplicates): The real challenge in 3Sum is avoiding duplicate triplets (e.g., [-1, -1, 2] appearing twice). As you can see in my code, I implemented while loops to skip over identical elements for both the fixed number and the pointers. It’s satisfying to see how sorting the data upfront makes a complex problem much more manageable. 3 days down! Consistency is building. 🧱 Has anyone tried extending this logic to "4Sum"? Does the recursion get messy? 👇 #200DaysOfCode #Python #LeetCode #Algorithms #TwoPointers #3Sum #ProblemSolving #CodingChallenge #DeveloperJourney

🚀 Day 16/160 – GFG DSA Challenge Today’s focus: Valid Anagram (Optimal Approach) 🔹 Topic: Strings / Hashing 🔹 Approach: Instead of sorting, used a frequency map to achieve linear time complexity. • increment count for characters in the first string • decrement count for characters in the second string • if all frequencies become zero → strings are anagrams 🔹 Complexity: ⏱ Time – O(n) 📦 Space – O(n) 💡 Key Learning: Sorting is intuitive but not always optimal. Using a hash map for frequency counting reduces time complexity from O(n log n) to O(n), which is a big improvement for large inputs. Focusing more on writing efficient logic rather than just making the code work 💪 #DSA #GFG160 #Day16 #Strings #Hashing #Python #ProblemSolving #Consistency