 Open in App
Not now

# Count triplets from a sorted array having difference between adjacent elements equal to D

• Last Updated : 25 May, 2021

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 = 3
Output: 3
Explanation:
Following are the triplets having the difference between the adjacent elements is D(= 3) are:

1. {1, 4, 7}
2. {4, 7, 10}
3. {2, 5, 8}

Therefore, the total count of triplets is 3.

Input: arr[] = {1, 2, 4, 5, 7, 8, 10}, D = 1
Output: 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(N3)
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].
• 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 ` `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 freq = ``new` `HashMap();`   `    ``// 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

 ``

Output:

`0`

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

My Personal Notes arrow_drop_up
Related Articles