Number of Divisible Triplet Sums - Practice Coding Problems

Number of Divisible Triplet Sums - Problem

You're given a 0-indexed integer array nums and an integer d. Your task is to find how many triplets of indices (i, j, k) exist such that:

i < j < k (indices must be in ascending order)
(nums[i] + nums[j] + nums[k]) % d == 0 (sum is divisible by d)

Think of this as finding special combinations of three numbers whose sum has a specific mathematical property. For example, if nums = [3, 3, 4, 7, 8] and d = 5, the triplet at indices (0, 1, 2) gives us 3 + 3 + 4 = 10, and 10 % 5 = 0, so this counts as a valid triplet.

Goal: Return the total count of such valid triplets.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3, 3, 4, 7, 8], d = 5

› Output: 2

💡 Note: Valid triplets are: (0,1,2) with sum 3+3+4=10, and (0,2,4) with sum 3+4+8=15. Both 10%5=0 and 15%5=0.

example_2.py — No Valid Triplets

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

› Output: 0

💡 Note: Only one possible triplet (0,1,2) with sum 1+2+3=6. Since 6%4=2≠0, there are no valid triplets.

example_3.py — All Elements Same

$ Input: nums = [2, 2, 2, 2, 2], d = 3

› Output: 10

💡 Note: Each triplet has sum 2+2+2=6, and 6%3=0. With 5 elements, there are C(5,3) = 10 possible triplets, all valid.

Constraints

3 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i] ≤ 10⁹
1 ≤ d ≤ 10⁹
Important: Array indices must satisfy i < j < k

Visualization

Tap to expand

Understanding the Visualization

Badge Assignment

Each number gets a 'remainder badge' showing its value mod d

Compatibility Rules

Three badges are compatible if their sum equals 0 mod d

Count Valid Groups

Use combinatorics to count all possible compatible triplets

Sum Results

Total all valid groupings from different badge combinations

Key Takeaway

🎯 Key Insight: By working with remainders instead of actual values, we transform a complex triplet-finding problem into a simple counting problem using modular arithmetic properties.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31 Apple 18

The optimal approach uses modular arithmetic with hash tables to count remainder frequencies. Instead of checking every triplet combination (O(n³)), we analyze remainder patterns and use combinatorial mathematics to count valid triplets in O(n + d²) time. The key insight is that (a + b + c) % d = 0 if and only if ((a % d) + (b % d) + (c % d)) % d = 0.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Remainder Counting)	O(n + d²)	O(d)	Count remainder frequencies first, then calculate triplet combinations mathematically
One-Pass Hash Table (Optimal)	O(n²)	O(min(n, d))	Build remainder frequency map and count valid triplets in a single pass
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet combination with three nested loops

Two-Pass Hash Table (Remainder Counting) — Algorithm Steps

Create a frequency map of remainders: count[i] = number of elements with remainder i when divided by d
Handle the special case where all three numbers have remainder 0: C(count[0], 3)
Handle cases where one number has remainder 0 and two others sum to remainder 0: count[0] * C(count[d/2], 2) if d is even
Handle general case where three different remainders sum to 0 (mod d): count[i] * count[j] * count[k] for valid (i,j,k)
Handle cases where two numbers have the same remainder r and one has remainder d-2r
Sum all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Remainders

For each number, calculate num % d and count frequencies

Case Analysis

Identify different patterns: (0,0,0), (0,i,d-i), (i,j,k) where i+j+k≡0(mod d)

Combinatorial Math

Use combinations to count valid triplets for each pattern

Sum Results

Add up counts from all valid remainder patterns

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

int numDivisibleSubsets(int* nums, int numsSize, int d) {
    // Count remainder frequencies
    int* count = calloc(d, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        int remainder = ((nums[i] % d) + d) % d; // Handle negative numbers
        count[remainder]++;
    }
    
    long long result = 0;
    
    // Case 1: All three have remainder 0
    if (count[0] >= 3) {
        result += (long long)count[0] * (count[0] - 1) * (count[0] - 2) / 6;
    }
    
    // Case 2: One has remainder 0, two others sum to 0 (mod d)
    for (int i = 1; i < (d + 1) / 2; i++) {
        int j = d - i;
        if (i != j) {
            result += (long long)count[0] * count[i] * count[j];
        } else if (count[i] >= 2) {
            result += (long long)count[0] * count[i] * (count[i] - 1) / 2;
        }
    }
    
    // Case 3: Three different remainders that sum to 0 (mod d)
    for (int i = 1; i < d; i++) {
        for (int j = i + 1; j < d; j++) {
            int k = (d - (i + j) % d) % d;
            if (k > j) {
                result += (long long)count[i] * count[j] * count[k];
            }
        }
    }
    
    free(count);
    return (int)result;
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    
    cJSON *json = cJSON_Parse(buffer);
    cJSON *numsJson = cJSON_GetObjectItem(json, "nums");
    cJSON *dJson = cJSON_GetObjectItem(json, "d");
    
    int numsSize = cJSON_GetArraySize(numsJson);
    int *nums = malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        nums[i] = cJSON_GetArrayItem(numsJson, i)->valueint;
    }
    
    int d = dJson->valueint;
    
    printf("%d\n", numDivisibleSubsets(nums, numsSize, d));
    
    free(nums);
    cJSON_Delete(json);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + d²)

O(n) to count remainders, O(d²) to check all remainder combinations

✓ Linear Growth

Space Complexity

O(d)

Array to store count of each remainder from 0 to d-1

✓ Linear Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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

Two-Pass Hash Table (Remainder Counting) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler