Count Special Triplets - Practice Coding Problems

Count Special Triplets - Problem

You are given an integer array nums. Your task is to find and count all special triplets within this array.

A special triplet is defined as a triplet of indices (i, j, k) that satisfies these conditions:

0 ≤ i < j < k < n, where n = nums.length
nums[i] == nums[j] * 2 (the first element is double the second)
nums[k] == nums[j] * 2 (the third element is also double the second)

In other words, you're looking for triplets where the first and third elements are both exactly double the middle element, and they appear in strictly increasing order of indices.

Goal: Return the total count of such special triplets. Since the answer may be large, return it modulo 10⁹ + 7.

Example: In array [2, 4, 8, 4], indices (0, 1, 2) form a special triplet because nums[0] = 2, nums[1] = 4, nums[2] = 8, and both 2 and 8 equal 4 × 2.

Input & Output

example_1.py — Basic Case

$ Input: [4, 2, 8, 1, 4]

› Output: 1

💡 Note: There is one special triplet: indices (0, 1, 2) where nums[0] = 4, nums[1] = 2, nums[2] = 8. We have 4 = 2×2 and 8 = 2×2, but actually 8 ≠ 2×2, so this is incorrect. Let me reconsider: we need both nums[i] and nums[k] to equal nums[j]×2. So for middle element 2, we need first and third elements to be 4. We have 4 at index 0 and 4 at index 4, giving us triplet (0, 1, 4).

example_2.py — Multiple Triplets

$ Input: [1, 2, 1, 2, 1]

› Output: 4

💡 Note: Multiple special triplets exist: (0,1,2), (0,1,4), (0,3,4), and (2,3,4). For each middle element with value 2, we need first and third elements with value 4. Since we have 1s at positions 0,2,4 and 2s at positions 1,3, we get 2×2=4 valid combinations.

example_3.py — No Valid Triplets

$ Input: [1, 3, 5]

› Output: 0

💡 Note: No special triplets exist. For the middle element 3 at index 1, we would need elements with value 6 at indices 0 and 2, but we have 1 and 5 instead.

Visualization

Tap to expand

Understanding the Visualization

Select Middle Element

Choose each array element as a potential middle element of the triplet

Count Valid First Elements

Count how many elements before the middle equal middle × 2

Count Valid Third Elements

Count how many elements after the middle equal middle × 2

Multiply and Sum

For each middle element, multiply left count × right count and add to total

Key Takeaway

🎯 Key Insight: Instead of checking all O(n³) triplets, we can decompose the problem by fixing the middle element and independently counting valid left and right elements, reducing complexity to O(n²).

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through array, but for each element we scan the remaining elements

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store frequency counts of elements seen so far

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 3000
0 ≤ nums[i] ≤ 200
All array elements are non-negative integers
Important: Return result modulo 10⁹ + 7

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal approach uses a two-pass counting strategy where for each middle element, we count valid first elements (using a hash map) and valid third elements (by scanning remaining array). The key insight is that triplet counting can be decomposed into independent left and right counting problems, achieving O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table Optimization	O(n²)	O(n)	Precompute counts, then calculate triplets for each middle element
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet (i,j,k) with i < j < k
One-Pass Hash Table (Optimal)	O(n²)	O(n)	Build hash map and count triplets simultaneously in a single pass

Two-Pass Hash Table Optimization — Algorithm Steps

Create frequency maps for elements before and after each position
For each position j, count elements at positions < j
For each position j, count elements at positions > j
For each middle element nums[j], find count of nums[j]*2 before and after j
Multiply these counts and add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Middle Element

Choose each element as potential middle element j

Count Left Elements

Count occurrences of nums[j]*2 before position j

Count Right Elements

Count occurrences of nums[j]*2 after position j

Multiply Counts

Add leftCount × rightCount to total

Code -

solution.c — C

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

int countSpecialTriplets(int* nums, int n) {
    const int MOD = 1000000007;
    long long count = 0;
    
    for (int j = 1; j < n - 1; j++) {
        int leftCount = 0;
        for (int i = 0; i < j; i++) {
            if (nums[i] == nums[j] * 2) {
                leftCount++;
            }
        }
        
        int rightCount = 0;
        for (int k = j + 1; k < n; k++) {
            if (nums[k] == nums[j] * 2) {
                rightCount++;
            }
        }
        
        count = (count + (long long)leftCount * rightCount) % MOD;
    }
    
    return (int)count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two passes: O(n) for building maps and O(n²) for counting at each position

⚠ Quadratic Growth

Space Complexity

O(n)

Hash maps to store frequency counts for each position

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 3000
0 ≤ nums[i] ≤ 200
All array elements are non-negative integers
Important: Return result modulo 10⁹ + 7

73.6K Views

Medium-High Frequency

~18 min Avg. Time

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

Two-Pass Hash Table Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler