Make Sum Divisible by P - Practice Coding Problems

Make Sum Divisible by P - Problem

You're given an array of positive integers nums and need to make the sum of the entire array divisible by a positive integer p. The twist? You can only achieve this by removing the smallest possible contiguous subarray.

Think of it as a precision surgery - you want to remove the minimal amount of elements while achieving your goal. The subarray you remove can be empty (if the sum is already divisible), but you cannot remove the entire array.

Your mission: Find the length of the smallest subarray that needs to be removed to make the remaining sum divisible by p. If it's impossible to achieve this goal, return -1.

Example: For nums = [3,1,4,2], p = 6, the total sum is 10. We need to remove a subarray with sum ≡ 4 (mod 6). The subarray [4] has sum 4, so removing it leaves sum 6, which is divisible by 6. Answer: 1.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Total sum is 10. We need 10 % 6 = 4 remainder gone. Subarray [4] has sum 4, removing it leaves sum 6 which is divisible by 6.

example_2.py — Already Divisible

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

› Output: 2

💡 Note: Total sum is 16. We need 16 % 9 = 7 remainder gone. Subarray [5,2] has sum 7, removing it leaves sum 9 which is divisible by 9.

example_3.py — 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.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ p ≤ 10⁹
Important: Cannot remove the entire array

Visualization

Tap to expand

Understanding the Visualization

Calculate Target

Find what remainder we need to eliminate: total_sum % p

Track Prefix Patterns

As we build prefix sums, track remainder patterns in hash map

Find Completion Points

When current_remainder - target_remainder matches a previous remainder, we found our subarray

Optimize Length

Keep track of the shortest valid subarray found

Key Takeaway

🎯 Key Insight: By storing prefix sum remainders in a hash map, we can instantly find if there's a previous position that creates the exact subarray sum we need to remove!

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses prefix sums with hash table in O(n) time. Key insight: if we want to remove a subarray with remainder r, we need to find where (current_prefix_remainder - target_remainder) appeared before. This elegant approach leverages modular arithmetic to efficiently locate the shortest subarray to remove.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Use prefix sums and hash map to find target subarray in single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays and find the shortest one with the target remainder

One-Pass Hash Table (Optimal) — Algorithm Steps

Calculate total sum remainder = sum % p
If remainder is 0, return 0
Use hash map to store {prefix_remainder: earliest_index}
For each position, calculate current prefix sum remainder
Look for target = (current_remainder - remainder + p) % p in hash map
If found, update minimum length
Add current remainder to hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Calculate remainder = 4, initialize hash map with {0: -1}

Process Elements

For each element, update prefix sum and check for target remainder

Find Match

When we find target remainder in hash map, we've found a valid subarray

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void insert(HashNode** table, int key, int value) {
    int idx = hash(key);
    HashNode* node = malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = table[idx];
    table[idx] = node;
}

int search(HashNode** table, int key, int* found) {
    int idx = hash(key);
    HashNode* node = table[idx];
    while (node) {
        if (node->key == key) {
            *found = 1;
            return node->value;
        }
        node = node->next;
    }
    *found = 0;
    return -1;
}

int minSubarray(int* nums, int numsSize, int p) {
    long long totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    int remainder = totalSum % p;
    if (remainder == 0) return 0;
    
    int minLen = numsSize;
    long long prefixSum = 0;
    HashNode* remainderMap[HASH_SIZE] = {0};
    insert(remainderMap, 0, -1);
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        int currentRemainder = prefixSum % p;
        
        int target = (currentRemainder - remainder + p) % p;
        
        int found;
        int idx = search(remainderMap, target, &found);
        if (found) {
            if (i - idx < minLen) {
                minLen = i - idx;
            }
        }
        
        insert(remainderMap, currentRemainder, i);
    }
    
    return minLen < numsSize ? minLen : -1;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    int p;
    scanf("%d", &p);
    printf("%d\n", minSubarray(nums, numsSize, p));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different prefix sum remainders

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

876 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler