Count Good Triplets - Practice Coding Problems

Count Good Triplets - Problem

Array Enumeration Easy

Given an array of integers arr and three threshold values a, b, and c, your task is to count how many "good triplets" exist in the array.

A triplet (arr[i], arr[j], arr[k]) is considered good if it satisfies all of the following conditions:

0 ≤ i < j < k < arr.length (indices must be in ascending order)
|arr[i] - arr[j]| ≤ a (first two elements are close enough)
|arr[j] - arr[k]| ≤ b (second and third elements are close enough)
|arr[i] - arr[k]| ≤ c (first and third elements are close enough)

Where |x| denotes the absolute value of x.

Goal: Return the total count of good triplets found in the array.

Example: If arr = [3,0,1,1,9,7] with a=7, b=2, c=3, then triplet (3,0,1) at indices (0,1,2) is good because |3-0|=3≤7, |0-1|=1≤2, and |3-1|=2≤3.

Input & Output

example_1.py — Python

$ Input: arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3

› Output: 4

💡 Note: The 4 good triplets are: (3,0,1) at indices (0,1,2), (3,0,1) at indices (0,1,3), (3,1,1) at indices (0,2,3), and (0,1,1) at indices (1,2,3). Each satisfies all three distance conditions.

example_2.py — Python

$ Input: arr = [1,1,2,2,3], a = 0, b = 0, c = 1

› Output: 0

💡 Note: No triplets satisfy the strict conditions since a=0 and b=0 require adjacent elements to be identical, but no three consecutive elements form valid triplets with c=1.

example_3.py — Python

$ Input: arr = [7,3,7,3,7], a = 4, b = 4, c = 0

› Output: 4

💡 Note: With c=0, only triplets where first and third elements are identical work. The triplets (7,3,7) appear at indices (0,1,2), (0,1,4), (0,3,2), and (2,3,4).

Visualization

Tap to expand

Understanding the Visualization

Generate All Triplets

Use three nested loops to create all possible combinations where i < j < k

Check Distance Conditions

For each triplet, verify that all three pairwise distances are within thresholds

Count Valid Groups

Increment counter when all conditions are satisfied

Key Takeaway

🎯 Key Insight: Since we need to count ALL good triplets and verify multiple distance conditions for each, the triple nested loop approach is both necessary and optimal for this problem.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times, resulting in cubic time complexity

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter and loop variables

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 100
0 ≤ arr[i] ≤ 1000
0 ≤ a, b, c ≤ 1000
Small input size makes O(n³) solution acceptable

Asked in

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

The optimal approach uses triple nested loops to check all possible triplet combinations in O(n³) time. Since we need to count ALL good triplets and verify multiple distance conditions, this brute force approach is actually optimal for the problem constraints. The key insight is that with small input size (n ≤ 100), the cubic time complexity is acceptable and necessary.

Common Approaches

Approach	Time	Space	Notes
✓ Triple Nested Loops	O(n³)	O(1)	Check every possible triplet combination using three nested loops

Triple Nested Loops — Algorithm Steps

Use outer loop for index i from 0 to n-3
Use middle loop for index j from i+1 to n-2
Use inner loop for index k from j+1 to n-1
For each triplet (i,j,k), check if |arr[i]-arr[j]| ≤ a
Check if |arr[j]-arr[k]| ≤ b and |arr[i]-arr[k]| ≤ c
If all conditions are met, increment the counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Loops

Set up three nested loops with i < j < k constraint

Check Conditions

For each triplet, verify all three distance conditions

Count Valid Triplets

Increment counter when all conditions are satisfied

Code -

solution.c — C

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

int countGoodTriplets(int* arr, int arrSize, int a, int b, int c) {
    int count = 0;
    
    // Check all possible triplets
    for (int i = 0; i < arrSize - 2; i++) {
        for (int j = i + 1; j < arrSize - 1; j++) {
            for (int k = j + 1; k < arrSize; k++) {
                // Check all three conditions
                if (abs(arr[i] - arr[j]) <= a &&
                    abs(arr[j] - arr[k]) <= b &&
                    abs(arr[i] - arr[k]) <= c) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    int arr[] = {3, 0, 1, 1, 9, 7};
    int arrSize = 6;
    int a = 7, b = 2, c = 3;
    printf("%d\n", countGoodTriplets(arr, arrSize, a, b, c));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times, resulting in cubic time complexity

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter and loop variables

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 100
0 ≤ arr[i] ≤ 1000
0 ≤ a, b, c ≤ 1000
Small input size makes O(n³) solution acceptable

28.4K Views

Medium Frequency

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

Triple Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler