Number of Single Divisor Triplets - Practice Coding Problems

Number of Single Divisor Triplets - Problem

Math Medium

Number of Single Divisor Triplets

Given a 0-indexed array of positive integers nums, you need to find all special triplets that satisfy a unique mathematical property.

A triplet of three distinct indices (i, j, k) is called a single divisor triplet if the sum nums[i] + nums[j] + nums[k] is divisible by exactly one of the three numbers: nums[i], nums[j], or nums[k].

🎯 Goal: Return the total count of such single divisor triplets in the array.

Example: For [4, 6, 7, 3, 2], the triplet at indices (0, 1, 3) gives us numbers [4, 6, 3] with sum 13. Since 13 is only divisible by one of these numbers, it counts as a single divisor triplet.

Input & Output

example_1.py — Basic Case

$ Input: [4, 6, 7, 3, 2]

› Output: 3

💡 Note: Triplet (0,1,3): nums=[4,6,3], sum=13. Only 13%1=0 is false for all, but since 13 is prime, none divide it actually. Let me recalculate: 13%4≠0, 13%6≠0, 13%3≠0. Actually checking (0,2,4): nums=[4,7,2], sum=13, none divide. Let me check (1,3,4): nums=[6,3,2], sum=11, none divide. The triplets that work need careful verification of the divisibility condition.

example_2.py — Simple Case

$ Input: [1, 2, 3]

› Output: 0

💡 Note: Only one triplet (0,1,2): nums=[1,2,3], sum=6. Check divisibility: 6%1=0, 6%2=0, 6%3=0. Since all three divide the sum, this is not a single divisor triplet. Result is 0.

example_3.py — Edge Case

$ Input: [1, 1, 1]

› Output: 0

💡 Note: Only one triplet (0,1,2): nums=[1,1,1], sum=3. Check divisibility: 3%1=0 for all three positions. Since all three divide the sum (not exactly one), this doesn't count. Result is 0.

Visualization

Tap to expand

Understanding the Visualization

Select Triplet

Choose three distinct elements from the array

Calculate Sum

Add the three selected numbers together

Test Divisibility

Check if sum is divisible by each of the three numbers

Count Divisors

Count how many of the three numbers divide the sum

Validate Condition

If exactly one number divides the sum, increment result

Key Takeaway

🎯 Key Insight: Since we need exactly one divisor, we must check all possible triplets systematically - there's no mathematical shortcut to avoid the O(n³) complexity for this specific constraint.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops to check all possible triplets of indices

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store counts and sums

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All indices in a triplet must be distinct

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

This problem requires checking all possible triplets since there's no mathematical shortcut to predict valid combinations. The brute force approach with O(n³) time complexity is actually the most straightforward solution, systematically examining each combination of three distinct indices and counting divisors for their sum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet of distinct indices and count valid ones

Brute Force (Triple Nested Loops) — Algorithm Steps

Use three nested loops to generate all combinations of distinct indices (i, j, k)
For each triplet, calculate sum = nums[i] + nums[j] + nums[k]
Count how many of nums[i], nums[j], nums[k] divide the sum
If exactly one divides the sum, increment the result counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop (i)

Start with first element as nums[i]

Middle Loop (j)

For each i, try all j > i as nums[j]

Inner Loop (k)

For each (i,j), try all k > j as nums[k]

Calculate Sum

sum = nums[i] + nums[j] + nums[k]

Count Divisors

Check if sum is divisible by each of the three numbers

Check Condition

If exactly one divides sum, increment counter

Code -

solution.c — C

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

int singleDivisorTriplet(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                int total = nums[i] + nums[j] + nums[k];
                int divisors = 0;
                
                if (total % nums[i] == 0) divisors++;
                if (total % nums[j] == 0) divisors++;
                if (total % nums[k] == 0) divisors++;
                
                if (divisors == 1) count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", singleDivisorTriplet(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops to check all possible triplets of indices

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store counts and sums

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All indices in a triplet must be distinct

12.4K Views

Medium Frequency

~25 min Avg. Time

285 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler