Make Sum Divisible by P

Make Sum Divisible by P - Problem

Given an array of positive integers nums, remove the smallest subarray (possibly empty) such that the sum of the remaining elements is divisible by p. It is not allowed to remove the whole array.

Return the length of the smallest subarray that you need to remove, or -1 if it's impossible.

A subarray is defined as a contiguous block of elements in the array.

Input & Output

Example 1 — Basic Removal

$ Input: nums = [3,1,4,2], p = 6

› Output: 1

💡 Note: Total sum is 10. We need sum divisible by 6. Remove subarray [4] (length 1) to get [3,1,2] with sum 6, which is divisible by 6.

Example 2 — No Removal Needed

$ Input: nums = [6,3,5,2], p = 9

› Output: 2

💡 Note: Total sum is 16. Remove subarray [5,2] (length 2) to get [6,3] with sum 9, which is divisible by 9.

Example 3 — Impossible Case

$ Input: nums = [1,2,3], p = 3

› Output: 0

💡 Note: Total sum is 6, which is already divisible by 3. No removal needed, return 0.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ p ≤ 10⁹

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 12 a Amazon 8

The key insight is that we need to find the shortest subarray whose sum has the same remainder as the total sum modulo p. The optimal approach uses prefix sums with hash map to track remainders and find the minimum length subarray in O(n) time. Time: O(n), Space: O(min(n,p))

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n³) Space: O(1)

Calculate the sum of every possible contiguous subarray, check if removing it makes the total sum divisible by p. Keep track of the minimum length subarray that works.

Prefix Sum with Hash Map

⏱️ Time: O(n) Space: O(min(n,p))

Calculate prefix sums and store remainders in a hash map. For each position, check if we've seen the remainder that would create the target subarray sum when subtracted.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* nums, int n, int k) {
    qsort(nums, n, sizeof(int), compare);
    
    // Flip negative numbers first
    int i = 0;
    while (i < n && nums[i] < 0 && k > 0) {
        nums[i] = -nums[i];
        i++;
        k--;
    }
    
    // If k is still positive and odd, flip the smallest number
    if (k % 2 == 1) {
        qsort(nums, n, sizeof(int), compare);
        nums[0] = -nums[0];
    }
    
    int sum = 0;
    for (int i = 0; i < n; i++) sum += nums[i];
    return sum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100], n = 0;
    
    // Find the opening bracket
    char* start = strchr(line, '[');
    if (start) {
        start++; // move past '['
        char* token = strtok(start, ",]");
        while (token != NULL) {
            // Skip whitespace
            while (*token == ' ') token++;
            if (strlen(token) > 0) {
                nums[n++] = atoi(token);
            }
            token = strtok(NULL, ",]");
        }
    }
    
    int k;
    scanf("%d", &k);
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen