Number of Arithmetic Triplets - Practice Coding Problems

Number of Arithmetic Triplets - Problem

You are given a strictly increasing integer array nums and a positive integer diff. Your task is to find all arithmetic triplets in the array.

An arithmetic triplet is a set of three elements at indices (i, j, k) where:

i < j < k (indices are in order)
nums[j] - nums[i] == diff (first gap equals diff)
nums[k] - nums[j] == diff (second gap equals diff)

Example: In array [0, 1, 4, 6, 7, 10] with diff = 3, the triplet (1, 4, 7) forms an arithmetic sequence because 4 - 1 = 3 and 7 - 4 = 3.

Return the total count of unique arithmetic triplets.

Input & Output

example_1.py — Basic Case

$ Input: nums = [0,1,4,6,7,10], diff = 3

› Output: 2

💡 Note: There are 2 arithmetic triplets: (0,3,6) doesn't exist since 3 is not in array, but (1,4,7) and (4,7,10) are valid triplets where consecutive differences equal 3.

example_2.py — No Triplets

$ Input: nums = [4,5,6,7,8,9], diff = 2

› Output: 2

💡 Note: The arithmetic triplets are (4,6,8) and (5,7,9). Each has differences of 2 between consecutive elements.

example_3.py — Single Element

$ Input: nums = [1,5,7,12,15,18], diff = 3

› Output: 2

💡 Note: Two arithmetic triplets exist: (12,15,18) with differences of 3, but we need to check all possibilities systematically.

Visualization

Tap to expand

Understanding the Visualization

Build Lookup

Create hash set of all available notes (numbers)

Find Middle

For each note, check if it can be the middle of a harmony

Check Intervals

Verify that notes at exact intervals exist

Count Harmonies

Count all valid three-note arithmetic progressions

Key Takeaway

🎯 Key Insight: Use the middle element as anchor point - it's the most efficient way to verify arithmetic progressions in a sorted array!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash set operations for each element

✓ Linear Growth

Space Complexity

O(n)

Hash set stores up to n elements from the input array

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000
1 ≤ diff ≤ 50
nums is strictly increasing

Asked in

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

The optimal solution uses a hash set to achieve O(n) time complexity. For each element, we check if it can be the middle element of an arithmetic triplet by looking for num-diff in our seen elements and num+diff in the complete array. This leverages the strictly increasing property to avoid duplicate counting.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	Build complete hash table first, then search for triplet components
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets (i, j, k) with i < j < k
One-Pass Hash Set (Optimal)	O(n)	O(n)	Build hash set while checking for arithmetic triplets in single pass

Two-Pass Hash Table — Algorithm Steps

First pass: Add all elements to a hash set
Second pass: For each element as potential first element
Check if (element + diff) exists in the set (second element)
Check if (element + 2*diff) exists in the set (third element)
Count valid triplets found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

First pass: Add all array elements to hash set

Iterate Array

Second pass: Check each element as potential triplet start

Check Pattern

Look for num+diff and num+2*diff in hash set

Count Matches

Increment counter when arithmetic triplet is found

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool contains(int* nums, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (nums[i] == target) return true;
        if (nums[i] > target) break; // optimization for sorted array
    }
    return false;
}

int arithmeticTriplets(int* nums, int numsSize, int diff) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int second = nums[i] + diff;
        int third = nums[i] + 2 * diff;
        
        if (contains(nums, numsSize, second) && contains(nums, numsSize, third)) {
            count++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array, each with O(1) hash operations per element

✓ Linear Growth

Space Complexity

O(n)

Hash set stores all n elements from the input array

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000
1 ≤ diff ≤ 50
nums is strictly increasing

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler