Maximizing Element Frequency with Sorting and Sliding Window

Some problems break the standard sliding window pattern — especially when negative numbers are involved. 🚀 Day 104/365 — DSA Challenge Solved: Shortest Subarray with Sum at Least K Problem idea: We need to find the length of the shortest subarray whose sum is at least k. The challenge is that the array can contain negative numbers, so normal sliding window won't work. Efficient approach: Use Prefix Sum + Monotonic Deque. Steps: 1. Build a prefix sum array 2. Use a deque to store indices of useful prefix sums 3. While current sum − smallest prefix ≥ k → update answer 4. Maintain increasing order in deque by removing larger prefix sums from the back 5. This ensures we always get the shortest valid subarray This approach efficiently handles negative numbers while keeping optimal time complexity. ⏱ Time: O(n) 📦 Space: O(n) Day 104/365 complete. 💻 261 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #Deque #PrefixSum #LeetCode #LearningInPublic

When a problem asks for maintaining a condition on both minimum and maximum, monotonic data structures become very powerful. 🚀 Day 110/365 — DSA Challenge Solved: Longest Continuous Subarray With Absolute Diff ≤ Limit Problem idea: We need to find the longest subarray such that the difference between max and min elements is ≤ limit. Efficient approach: Use Sliding Window + Two Monotonic Deques. Steps: 1. Use one deque to maintain maximum elements (decreasing order) 2. Use another deque to maintain minimum elements (increasing order) 3. Expand window by moving the right pointer 4. If (max − min) exceeds limit, shrink window from the left 5. Track the maximum valid window size This ensures we can get max and min in O(1) time. ⏱ Time: O(n) 📦 Space: O(n) Day 110/365 complete. 💻 255 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #Deque #LeetCode #LearningInPublic

Day 46/75 — Frequency of the Most Frequent Element Today’s problem was about maximizing the frequency of an element using at most k increments. Approach: • Sort the array • Use sliding window • Maintain sum of current window • Expand right pointer • Shrink window when operations exceed k Key logic: while ((long) nums[right] * (right - left + 1) - total > k) {  total -= nums[left];  left++; } maxFreq = Math.max(maxFreq, right - left + 1); Time Complexity: O(n log n) (sorting) Space Complexity: O(1) Key Insight: Make all elements in window equal to the largest element — check if cost ≤ k. 46/75 🚀 #Day46 #DSA #SlidingWindow #TwoPointers #Java #Algorithms #LeetCode

Day 56/75 — Sliding Window Maximum Today’s problem was about finding the maximum element in every sliding window of size k. Approach: • Use a deque to store indices of useful elements • Maintain decreasing order in deque (front = max) • Remove elements out of current window Key logic: while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i]) { dq.pollLast(); } if (!dq.isEmpty() && dq.peekFirst() == i - k) { dq.pollFirst(); } dq.offerLast(i); Time Complexity: O(n) Space Complexity: O(k) A classic problem that strengthens sliding window + monotonic deque concepts. 56/75 🚀 #Day56 #DSA #SlidingWindow #Deque #Java #Algorithms #LeetCode

Not all sliding window problems are about sums — sometimes the constraint is on the product, but the pattern still applies. 🚀 Day 103/365 — DSA Challenge Solved: Subarray Product Less Than K Problem idea: We need to count the number of subarrays where the product of all elements is strictly less than k. Efficient approach: Use a sliding window that maintains a valid product. Steps: 1. Expand the window by multiplying the current element 2. If product becomes ≥ k, shrink the window from the left 3. Keep dividing until product < k 4. Count all valid subarrays ending at each index This works because all numbers are positive, so the window can be adjusted greedily. ⏱ Time: O(n) 📦 Space: O(1) Day 103/365 complete. 💻 262 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic

Some problems become much easier when you reframe the question. 🚀 Day 107/365 — DSA Challenge Solved: Minimum Operations to Reduce X to Zero Problem idea: We need to remove elements from the left or right so that their sum equals x, with minimum operations. Efficient approach: Instead of removing elements, think in reverse: 👉 Find the longest subarray with sum = totalSum − x Steps: 1. Calculate total sum of the array 2. Set target = totalSum − x 3. Find the longest subarray with sum = target using sliding window 4. Result = total length − longest subarray length This converts the problem into a familiar sliding window problem. ⏱ Time: O(n) 📦 Space: O(1) Day 107/365 complete. 💻 258 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic

Day 44 of Daily DSA 🚀 Solved LeetCode 1572: Matrix Diagonal Sum ✅ Problem: Given a square matrix mat, return the sum of the matrix diagonals. Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal. Approach: Used a two-pointer technique to traverse both diagonals in a single pass. Steps: Initialize two pointers → start = 0, end = n-1 Traverse each row: Add mat[i][start] (primary diagonal) Add mat[i][end] (secondary diagonal) Move pointers: start++, end-- If matrix size is odd → add center element once ⏱ Complexity: • Time: O(n) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 46.53 MB Optimizing nested loops into a single pass can make your solution both cleaner and faster 💡 #DSA #LeetCode #Java #Arrays #Matrix #CodingJourney #ProblemSolving

Day 48 of Daily DSA 🚀 Solved LeetCode 48: Rotate Image ✅ Problem: Given an n x n matrix, rotate the image by 90° clockwise — in-place (without using extra space). Approach: Used a two-step transformation: Transpose the matrix Reverse each row Steps: Traverse upper triangle and swap → matrix[i][j] ↔ matrix[j][i] For each row: Use two pointers (left, right) Swap elements to reverse the row Matrix gets rotated in-place ⏱ Complexity: • Time: O(n²) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.56 MB In-place transformations are powerful — no extra space, just smart manipulation 💡 #DSA #LeetCode #Java #Matrix #Arrays #CodingJourney #ProblemSolving

Many subarray problems follow the same hidden pattern — once you recognize it, they become much easier. 🚀 Day 102/365 — DSA Challenge Solved: Count Number of Nice Subarrays Problem idea: We need to count the number of subarrays that contain exactly k odd numbers. Efficient approach: Use the same trick as previous problem: subarrays with exactly k odds = subarrays with ≤ k odds − subarrays with ≤ (k − 1) odds Steps: 1. Use a sliding window to count subarrays with at most k odd numbers 2. Expand window by moving right pointer 3. If odd count exceeds k, shrink window from left 4. Add valid subarrays ending at each index 5. Subtract results to get exact count This pattern works beautifully for binary-like conditions. ⏱ Time: O(n) 📦 Space: O(1) Day 102/365 complete. 💻 263 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic

Some problems look difficult at first, but once you know the right data structure, they become much easier. 🚀 Day 99/365 — DSA Challenge Solved: Sliding Window Maximum Problem idea: We are given an array and a window of size k that moves from left to right. For each window position, we need to find the maximum element inside that window. Efficient approach: Use a Deque (Double Ended Queue) to keep track of useful elements for the current window. Steps: 1. Store indices in the deque 2. Remove indices that are outside the current window 3. Remove elements smaller than the current element from the back 4. The front of the deque always stores the index of the maximum element 5. Record the maximum once the first window is formed This ensures we always know the maximum of the current window efficiently. ⏱ Time: O(n) 📦 Space: O(k) Day 99/365 complete. 💻 266 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #Deque #LeetCode #LearningInPublic