Related Articles

# 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)

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up