Number of Unequal Triplets in Array - Practice Coding Problems

Number of Unequal Triplets in Array - Problem

Number of Unequal Triplets in Array

You're given an array of positive integers, and your task is to find all the unique triplets where each element in the triplet is different from the others.

More specifically, you need to count triplets (i, j, k) where:
• The indices satisfy 0 ≤ i < j < k < nums.length
• All three values are pairwise distinct: nums[i] ≠ nums[j] ≠ nums[k] ≠ nums[i]

Example: In array [4, 4, 2, 4, 3], the triplet at indices (2, 4, 1) becomes (2, 3, 4) in terms of values - all different!

Return the total count of such valid triplets.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The valid triplets are: (0,2,4) with values (4,2,3), (1,2,4) with values (4,2,3), (3,2,4) with values (4,2,3). All have distinct values.

example_2.py — All Same Values

$ Input: [1,1,1]

› Output: 0

💡 Note: No valid triplets exist since all values are the same (1,1,1), violating the distinct requirement.

example_3.py — All Different Values

$ Input: [1,3,2,5,4]

› Output: 10

💡 Note: Since all values are unique, every possible triplet of indices forms a valid solution. Total = C(5,3) = 10 triplets.

Visualization

Tap to expand

Understanding the Visualization

Count People by Cuisine

First, count how many people like Italian (3), Chinese (1), Mexican (1)

Form Mixed Groups

To form groups with all different preferences, pick 1 from each cuisine type

Calculate Combinations

Total groups = 3 × 1 × 1 = 3 different dinner groups possible

Key Takeaway

🎯 Key Insight: Use the multiplication principle from combinatorics - if you have groups of different sizes, multiply their sizes to get total combinations. This transforms an O(n³) problem into O(n + k³) where k is unique values!

Time & Space Complexity

Time Complexity

⏱️

O(n + k³)

O(n) to build frequency map + O(k³) to check all combinations of k unique values

✓ Linear Growth

Space Complexity

O(k)

Space for frequency map storing k unique values

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Array has at least 3 elements

Asked in

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

The optimal solution uses frequency counting instead of checking every triplet. Count how many times each unique value appears, then for every combination of 3 different values, multiply their frequencies to get the number of valid triplets. This reduces complexity from O(n³) to O(n + k³) where k is the number of unique values.

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Counting (Optimal)	O(n + k³)	O(k)	Count frequencies of each value and use mathematical combinations
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet of indices and count those with distinct values

Frequency Counting (Optimal) — Algorithm Steps

Create a frequency map counting occurrences of each unique value
Extract all unique values into a list
For each combination of 3 different unique values, multiply their frequencies
Sum all the products to get total valid triplets

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map of unique values

Find Combinations

Consider all combinations of 3 unique values

Multiply Frequencies

For each combo, multiply the frequencies

Code -

solution.c — C

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

#define MAX_VAL 1001

int unequalTriplets(int* nums, int n) {
    int freq[MAX_VAL] = {0};
    int uniqueVals[MAX_VAL];
    int k = 0;
    
    // Count frequencies
    for (int i = 0; i < n; i++) {
        if (freq[nums[i]] == 0) {
            uniqueVals[k++] = nums[i];
        }
        freq[nums[i]]++;
    }
    
    int count = 0;
    
    // Check all combinations of 3 different values
    for (int i = 0; i < k; i++) {
        for (int j = i + 1; j < k; j++) {
            for (int l = j + 1; l < k; l++) {
                count += freq[uniqueVals[i]] * freq[uniqueVals[j]] * freq[uniqueVals[l]];
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", unequalTriplets(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k³)

O(n) to build frequency map + O(k³) to check all combinations of k unique values

✓ Linear Growth

Space Complexity

O(k)

Space for frequency map storing k unique values

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Array has at least 3 elements

28.7K Views

Medium Frequency

~15 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Frequency Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler