Number of Unequal Triplets in Array

Number of Unequal Triplets in Array - Problem

You are given a 0-indexed array of positive integers nums. Find the number of triplets (i, j, k) that meet the following conditions:

0 <= i < j < k < nums.length
nums[i], nums[j], and nums[k] are pairwise distinct.
In other words, nums[i] != nums[j], nums[i] != nums[k], and nums[j] != nums[k].

Return the number of triplets that meet the conditions.

Input & Output

Example 1 — Basic Case

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

› Output: 3

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

Example 2 — No Valid Triplets

$ Input: nums = [1,1,1,1,1]

› Output: 0

💡 Note: All elements are the same, so no triplet can have pairwise distinct values.

Example 3 — All Unique

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

› Output: 1

💡 Note: Only one triplet (0,1,2) with values (1,2,3), all distinct.

Constraints

3 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 10

The key insight is to count frequencies first rather than checking every triplet. The optimal approach uses frequency counting with combinatorics: O(n + U³) time, O(U) space where U is unique values.

Common Approaches

✓ Brute Force - Triple Nested Loop

⏱️ Time: O(n³) Space: O(1)

Use three nested loops to examine every possible triplet of indices where i < j < k. For each triplet, check if all three values are different and increment counter if they are.

Frequency Count with Combinatorics

⏱️ Time: O(n + U³) Space: O(U)

Count how many times each unique value appears in the array. For each combination of three different values, multiply their frequencies to get the number of valid triplets with those values.

Brute Force - Triple Nested Loop — Algorithm Steps

Step 1: Use three nested loops for i, j, k where i < j < k
Step 2: For each triplet, check if nums[i] != nums[j] != nums[k]
Step 3: Count valid triplets and return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Triple Loop

Generate all combinations with i < j < k

Check Distinct

Verify all three values are different

Count Valid

Increment counter for valid triplets

Code -

solution.c — C

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

int solution(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++) {
                if (nums[i] != nums[j] && nums[i] != nums[k] && nums[j] != nums[k]) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int size = 0;
    char* ptr = line + 1; // Skip '['
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and loop indices

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

245 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

Brute Force - Triple Nested Loop — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler