chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-30-1590-Make-Sum-Divisible-by-P/explanation.md

@@ -0,0 +1,35 @@
+# Make Sum Divisible by P (Medium)
+
+**Problem ID:** 1590  
+**Date:** 2025-11-30  
+**Link:** https://leetcode.com/problems/make-sum-divisible-by-p/
+
+## Approach
+
+To solve the problem of finding the smallest subarray to remove such that the sum of the remaining elements is divisible by `p`, we can follow these steps:
+
+### Main Idea:
+1. **Calculate Total Sum**: First, compute the total sum of the array `nums`. If this sum is already divisible by `p`, then no removal is needed, and we can return `0`.
+  
+2. **Determine Remainder**: If the total sum is not divisible by `p`, calculate the remainder when the total sum is divided by `p`. This remainder indicates how much we need to adjust the sum to make it divisible by `p`.
+
+3. **Use Prefix Sums and HashMap**: To efficiently find the smallest subarray that can be removed:
+   - Maintain a running prefix sum while iterating through the array.
+   - Store the indices of the prefix sums modulo `p` in a HashMap. This allows us to quickly find the last occurrence of a specific remainder.
+   - For each element, check if removing a subarray that leads to the desired adjustment (i.e., the prefix sum modulo `p` matching the required remainder) can yield a valid solution.
+
+4. **Calculate Minimum Length**: For each valid prefix sum that can help achieve the desired sum, calculate the length of the subarray that would need to be removed. Keep track of the minimum length found.
+
+### Data Structures:
+- An integer variable to store the total sum of the array.
+- A HashMap (or dictionary) to store the last seen index of each prefix sum modulo `p`.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the input array. We make a single pass through the array to compute the total sum and another pass to find the minimum removable subarray.
+- **Space Complexity**: O(p) in the worst case, due to storing the indices of prefix sums in the HashMap.
+
+### Edge Cases:
+- If the total sum is less than `p`, check if removing any single element can achieve the desired condition.
+- If no valid subarray can be found, return `-1`.
+
+By following this structured approach, we can efficiently determine the length of the smallest subarray to remove, ensuring that the solution is both optimal and clear.

Medium/2025-11-30-1590-Make-Sum-Divisible-by-P/solution.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int minSubarray(int[] nums, int p) {
+        long totalSum = 0;
+        for (int num : nums) {
+            totalSum += num;
+        }
+        
+        long remainder = totalSum % p;
+        if (remainder == 0) return 0;
+        
+        int n = nums.length;
+        Map<Long, Integer> prefixMap = new HashMap<>();
+        prefixMap.put(0L, -1);
+        long currentSum = 0;
+        int minLength = Integer.MAX_VALUE;
+        
+        for (int i = 0; i < n; i++) {
+            currentSum += nums[i];
+            long target = (currentSum % p - remainder + p) % p;
+            if (prefixMap.containsKey(target)) {
+                minLength = Math.min(minLength, i - prefixMap.get(target));
+            }
+            prefixMap.put(currentSum % p, i);
+        }
+        
+        return minLength == Integer.MAX_VALUE ? -1 : minLength;
+    }
+}

Medium/2025-11-30-1590-Make-Sum-Divisible-by-P/solution.js

@@ -0,0 +1,25 @@
+var minSubarray = function(nums, p) {
+    const totalSum = nums.reduce((a, b) => a + b, 0);
+    const remainder = totalSum % p;
+
+    if (remainder === 0) return 0;
+
+    const n = nums.length;
+    const map = new Map();
+    map.set(0, -1);
+    let currentSum = 0;
+    let minLength = Infinity;
+
+    for (let i = 0; i < n; i++) {
+        currentSum += nums[i];
+        const mod = currentSum % p;
+
+        if (map.has((mod - remainder + p) % p)) {
+            minLength = Math.min(minLength, i - map.get((mod - remainder + p) % p));
+        }
+
+        map.set(mod, i);
+    }
+
+    return minLength === Infinity ? -1 : minLength;
+};

Medium/2025-11-30-1590-Make-Sum-Divisible-by-P/solution.py

@@ -0,0 +1,25 @@
+class Solution:
+    def minSubarray(self, nums: List[int], p: int) -> int:
+        total_sum = sum(nums)
+        remainder = total_sum % p
+        
+        if remainder == 0:
+            return 0
+        
+        n = len(nums)
+        min_length = float('inf')
+        prefix_sum = 0
+        prefix_map = {0: -1}
+        
+        for i in range(n):
+            prefix_sum += nums[i]
+            current_remainder = prefix_sum % p
+            
+            target_remainder = (current_remainder - remainder + p) % p
+            
+            if target_remainder in prefix_map:
+                min_length = min(min_length, i - prefix_map[target_remainder])
+            
+            prefix_map[current_remainder] = i
+        
+        return min_length if min_length != float('inf') else -1

README.md

@@ -290,3 +290,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-23 — [Greatest Sum Divisible by Three](https://leetcode.com/problems/greatest-sum-divisible-by-three/) (Medium) → `Medium/2025-11-23-1262-Greatest-Sum-Divisible-by-Three`
 - 2025-11-24 — [Binary Prefix Divisible By 5](https://leetcode.com/problems/binary-prefix-divisible-by-5/) (Easy) → `Easy/2025-11-24-1018-Binary-Prefix-Divisible-By-5`
 - 2025-11-25 — [Smallest Integer Divisible by K](https://leetcode.com/problems/smallest-integer-divisible-by-k/) (Medium) → `Medium/2025-11-25-1015-Smallest-Integer-Divisible-by-K`
+- 2025-11-30 — [Make Sum Divisible by P](https://leetcode.com/problems/make-sum-divisible-by-p/) (Medium) → `Medium/2025-11-30-1590-Make-Sum-Divisible-by-P`