Given a sorted array **arr[]** consisting of **N** positive integers and an integer **D**, the task is to find the number of triplets **(i, j, k)** such that **arr[j] – arr[i] = D** and **arr[k] – arr[j] = D **and **0 ≤ i < j < k < N**.

**Examples:**

Input:arr[] = {1, 2, 4, 5, 7, 8, 10}, D = 3Output:3Explanation:

Following are the triplets having the difference between the adjacent elements is D(= 3) are:

- {1, 4, 7}
- {4, 7, 10}
- {2, 5, 8}
Therefore, the total count of triplets is 3.

Input:arr[] = {1, 2, 4, 5, 7, 8, 10}, D = 1Output:0

**Naive Approach:** The simplest approach to solve this problem is to generate all the triplets of the given array and count those triplets having the difference between the adjacent elements is D(= 3).

**Time Complexity:** O(N^{3})**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can also be optimized by considering every element of the array as the last element of the triplet and check for the previous two elements i.e., **(arr[i] – D)** and **(arr[i] – 2 * D)** exists in the array or not. Follow the steps below to solve the problem.

- Initialize a HashMap, say
**M**that stores the frequency of the array elements. - Initialize a variable, say
**ans**as**0**. - Traverse the given array
**arr[]**and perform the following steps:- Increment the frequency of
**arr[i]**by**1**in the HashMap**M**. - Now, check if the element
**(arr[i] – D)**and**(arr[i] – 2 * D)**are present in the HashMap or not. If found to be**true**, then increment the value of**ans**by**freq[arr[i] – D] * freq[arr[i] – 2 * D]**.

- Increment the frequency of
- After completing the above steps, print the value of
**ans**as the resultant count of triplets in the array.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to count the number of` `// triplets having difference` `// between adjacent elements equal to D` `int` `countTriplets(` `int` `D, vector<` `int` `>& arr)` `{` ` ` `// Stores the frequency` ` ` `// of array elements` ` ` `unordered_map<` `int` `, ` `int` `> freq;` ` ` `// Stores the count of` ` ` `// resultant triplets` ` ` `int` `ans = 0;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < arr.size(); i++) {` ` ` `// Check if arr[i] - D and` ` ` `// arr[i] - 2 * D exists` ` ` `// in the Hashmap or not` ` ` `if` `(freq.find(arr[i] - D)` ` ` `!= freq.end()` ` ` `&& freq.find(arr[i] - 2 * D)` ` ` `!= freq.end()) {` ` ` `// Update the value of ans` ` ` `ans += freq[arr[i] - D]` ` ` `* freq[arr[i] - 2 * D];` ` ` `}` ` ` `// Increase the frequency` ` ` `// of the current element` ` ` `freq[arr[i]]++;` ` ` `}` ` ` `// Return the resultant count` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `vector<` `int` `> arr{ 1, 2, 4, 5, 7, 8, 10 };` ` ` `int` `D = 1;` ` ` `cout << countTriplets(D, arr);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to count the number of` `// triplets having difference` `// between adjacent elements equal to D` `static` `int` `countTriplets(` `int` `D, ` `int` `[]arr)` `{` ` ` ` ` `// Stores the frequency` ` ` `// of array elements` ` ` `HashMap<Integer,` ` ` `Integer> freq = ` `new` `HashMap<Integer,` ` ` `Integer>();` ` ` `// Stores the count of` ` ` `// resultant triplets` ` ` `int` `ans = ` `0` `;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `0` `; i < arr.length; i++)` ` ` `{` ` ` ` ` `// Check if arr[i] - D and` ` ` `// arr[i] - 2 * D exists` ` ` `// in the Hashmap or not` ` ` `if` `(freq.containsKey(arr[i] - D) &&` ` ` `freq.containsKey(arr[i] - ` `2` `* D))` ` ` `{` ` ` ` ` `// Update the value of ans` ` ` `ans += freq.get(arr[i] - D) *` ` ` `freq.get(arr[i] - ` `2` `* D);` ` ` `}` ` ` `// Increase the frequency` ` ` `// of the current element` ` ` `if` `(freq.containsKey(arr[i]))` ` ` `{` ` ` `freq.put(arr[i], freq.get(arr[i]) + ` `1` `);` ` ` `}` ` ` `else` ` ` `{` ` ` `freq.put(arr[i], ` `1` `);` ` ` `}` ` ` `}` ` ` `// Return the resultant count` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `[]arr = { ` `1` `, ` `2` `, ` `4` `, ` `5` `, ` `7` `, ` `8` `, ` `10` `};` ` ` `int` `D = ` `1` `;` ` ` ` ` `System.out.print(countTriplets(D, arr));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 program for the above approach` `# Function to count the number of` `# triplets having difference` `# between adjacent elements equal to D` `def` `countTriplets(D, arr):` ` ` ` ` `# Stores the frequency` ` ` `# of array elements` ` ` `freq ` `=` `{}` ` ` `# Stores the count of` ` ` `# resultant triplets` ` ` `ans ` `=` `0` ` ` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(` `len` `(arr)):` ` ` ` ` `# Check if arr[i] - D and` ` ` `# arr[i] - 2 * D exists` ` ` `# in the Hashmap or not` ` ` `if` `(((arr[i] ` `-` `D) ` `in` `freq) ` `and` ` ` `(arr[i] ` `-` `2` `*` `D) ` `in` `freq):` ` ` ` ` `# Update the value of ans` ` ` `ans ` `+` `=` `(freq[arr[i] ` `-` `D] ` `*` ` ` `freq[arr[i] ` `-` `2` `*` `D])` ` ` `# Increase the frequency` ` ` `# of the current element` ` ` `freq[arr[i]] ` `=` `freq.get(arr[i], ` `0` `) ` `+` `1` ` ` `# Return the resultant count` ` ` `return` `ans` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `arr ` `=` `[ ` `1` `, ` `2` `, ` `4` `, ` `5` `, ` `7` `, ` `8` `, ` `10` `]` ` ` `D ` `=` `1` ` ` ` ` `print` `(countTriplets(D, arr))` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to count the number of` `// triplets having difference` `// between adjacent elements equal to D` `static` `int` `countTriplets(` `int` `D, ` `int` `[] arr)` `{` ` ` ` ` `// Stores the frequency` ` ` `// of array elements` ` ` `Dictionary<` `int` `,` ` ` `int` `> freq = ` `new` `Dictionary<` `int` `,` ` ` `int` `>();` ` ` `// Stores the count of` ` ` `// resultant triplets` ` ` `int` `ans = 0;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < arr.Length; i++)` ` ` `{` ` ` ` ` `// Check if arr[i] - D and` ` ` `// arr[i] - 2 * D exists` ` ` `// in the Hashmap or not` ` ` `if` `(freq.ContainsKey(arr[i] - D) &&` ` ` `freq.ContainsKey(arr[i] - 2 * D))` ` ` `{` ` ` ` ` `// Update the value of ans` ` ` `ans += freq[arr[i] - D] *` ` ` `freq[arr[i] - 2 * D];` ` ` `}` ` ` `// Increase the frequency` ` ` `// of the current element` ` ` `if` `(!freq.ContainsKey(arr[i]))` ` ` `freq[arr[i]] = 0;` ` ` ` ` `freq[arr[i]]++;` ` ` `}` ` ` `// Return the resultant count` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `Main()` `{` ` ` `int` `[] arr = { 1, 2, 4, 5, 7, 8, 10 };` ` ` `int` `D = 1;` ` ` ` ` `Console.WriteLine(countTriplets(D, arr));` `}` `}` `// This code is contributed by ukasp` |

## Javascript

`<script>` `// javascript program for the above approach` `// Function to count the number of` `// triplets having difference` `// between adjacent elements equal to D` `function` `countTriplets(D, arr)` `{` ` ` `// Stores the frequency` ` ` `// of array elements` ` ` `var` `freq = ` `new` `Map();` ` ` ` ` `// Stores the count of` ` ` `// resultant triplets` ` ` `var` `ans = 0;` ` ` `var` `i;` ` ` `// Traverse the array` ` ` `for` `(i = 0; i < arr.length; i++) {` ` ` `// Check if arr[i] - D and` ` ` `// arr[i] - 2 * D exists` ` ` `// in the Hashmap or not` ` ` `if` `(freq.has(arr[i] - D) && freq.has(arr[i] - 2 * D)) {` ` ` `// Update the value of ans` ` ` `ans += freq.get(arr[i] - D) * freq.get(arr[i] - 2 * D);` ` ` `}` ` ` `// Increase the frequency` ` ` `// of the current element` ` ` `freq.set(arr[i],freq.get(arr[i])+1);` ` ` `}` ` ` `// Return the resultant count` ` ` `return` `ans;` `}` `// Driver Code` ` ` `var` `arr = [1, 2, 4, 5, 7, 8, 10];` ` ` `var` `D = 1;` ` ` `document.write(countTriplets(D, arr));` `</script>` |

**Output:**

0

**Time Complexity:** O(N) **Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**