# Count Subarrays with Consecutive elements differing by 1

Given an array arr[] of N integers. The task is to count the total number of subarrays of the given array such that difference between the consecutive elements in the subarrays is one. That is, for any index in the subarrays, arr[i+1] – arr[i] = 1.

Note: Do not consider subarrays with single element.

Examples:

```Input : arr[] = {1, 2, 3}
Output : 3
The subarrays are {1, 2}. {2, 3} and {1, 2, 3}

Input : arr[] = {1, 2, 3, 5, 6, 7}
Output : 6
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: A simple approach is to run two nested loops and check every subarray and calculate the count of subarrays with consecutive elements differing by 1.

Efficient Approach: An efficient approach is to observe that in an array of length say K, total number of subarrays of size greater than 1 = (K)*(K-1)/2.

So, the idea is to traverse the array by using two pointers to calculate subarrays with consecutive elements in a window of maximum length and then calculate all subarrays in that window using the above formula.

Below is the step by step algorithm:

• Take two pointers say fast and slow, for maintaining a window of consecutive elements.
• Start traversing the array.
• If elements differ by 1 increment only the fast pointer.
• Else, calculate the length of current window between the indexes fast and slow.

Below is the implementation of the given approach:

## C++

 `// C++ program to count Subarrays with ` `// Consecutive elements differing by 1 ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to count Subarrays with ` `// Consecutive elements differing by 1 ` `int` `subarrayCount(``int` `arr[], ``int` `n) ` `{ ` `    ``// Variable to store count of subarrays ` `    ``// whose consecutive elements differ by 1 ` `    ``int` `result = 0; ` ` `  `    ``// Take two pointers for maintaining a ` `    ``// window of consecutive elements ` `    ``int` `fast = 0, slow = 0; ` ` `  `    ``// Traverse the array ` `    ``for` `(``int` `i = 1; i < n; i++) { ` ` `  `        ``// If elements differ by 1 ` `        ``// increment only the fast pointer ` `        ``if` `(arr[i] - arr[i - 1] == 1) { ` `            ``fast++; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Calculate length of subarray ` `            ``int` `len = fast - slow + 1; ` ` `  `            ``// Calculate total subarrays except  ` `            ``// Subarrays with single element ` `            ``result += len * (len - 1) / 2; ` ` `  `            ``// Update fast and slow ` `            ``fast = i; ` `            ``slow = i; ` `        ``} ` `    ``} ` ` `  `    ``// For last iteration. That is if array is ` `    ``// traversed and fast > slow ` `    ``if` `(fast != slow) { ` `        ``int` `len = fast - slow + 1; ` `        ``result += len * (len - 1) / 2; ` `    ``} ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``int` `arr[] = { 1, 2, 3, 5, 6, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``cout << subarrayCount(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to count Subarrays with ` `// Consecutive elements differing by 1 ` `class` `cfg  ` `{ ` ` `  `// Function to count Subarrays with ` `// Consecutive elements differing by 1 ` `static` `int` `subarrayCount(``int` `arr[], ``int` `n) ` `{ ` `    ``// Variable to store count of subarrays ` `    ``// whose consecutive elements differ by 1 ` `    ``int` `result = ``0``; ` ` `  `    ``// Take two pointers for maintaining a ` `    ``// window of consecutive elements ` `    ``int` `fast = ``0``, slow = ``0``; ` ` `  `    ``// Traverse the array ` `    ``for` `(``int` `i = ``1``; i < n; i++) { ` ` `  `        ``// If elements differ by 1 ` `        ``// increment only the fast pointer ` `        ``if` `(arr[i] - arr[i - ``1``] == ``1``) { ` `            ``fast++; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Calculate length of subarray ` `            ``int` `len = fast - slow + ``1``; ` ` `  `            ``// Calculate total subarrays except  ` `            ``// Subarrays with single element ` `            ``result += len * (len - ``1``) / ``2``; ` ` `  `            ``// Update fast and slow ` `            ``fast = i; ` `            ``slow = i; ` `        ``} ` `    ``} ` ` `  `    ``// For last iteration. That is if array is ` `    ``// traversed and fast > slow ` `    ``if` `(fast != slow) { ` `        ``int` `len = fast - slow + ``1``; ` `        ``result += len * (len - ``1``) / ``2``; ` `    ``} ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` `  `    ``int` `arr[] = { ``1``, ``2``, ``3``, ``5``, ``6``, ``7` `}; ` `    ``int` `n = arr.length; ` ` `  `    ``System.out.println(subarrayCount(arr, n)); ` ` `  `} ` `} ` `//This code is contributed by Mukul Singh `

## Python3

 `# Python3 program to count Subarrays with  ` `# Consecutive elements differing by 1  ` ` `  `# Function to count Subarrays with  ` `# Consecutive elements differing by 1  ` `def` `subarrayCount(arr, n) : ` `     `  `    ``# Variable to store count of subarrays  ` `    ``# whose consecutive elements differ by 1  ` `    ``result ``=` `0` ` `  `    ``# Take two pointers for maintaining a  ` `    ``# window of consecutive elements  ` `    ``fast, slow ``=` `0``, ``0` ` `  `    ``# Traverse the array  ` `    ``for` `i ``in` `range``(``1``, n) :  ` ` `  `        ``# If elements differ by 1  ` `        ``# increment only the fast pointer  ` `        ``if` `(arr[i] ``-` `arr[i ``-` `1``] ``=``=` `1``) :  ` `            ``fast ``+``=` `1` `         `  `        ``else` `:  ` ` `  `            ``# Calculate length of subarray  ` `            ``length ``=` `fast ``-` `slow ``+` `1` ` `  `            ``# Calculate total subarrays except  ` `            ``# Subarrays with single element  ` `            ``result ``+``=` `length ``*` `(length ``-` `1``) ``/``/` `2``;  ` ` `  `            ``# Update fast and slow  ` `            ``fast ``=` `i ` `            ``slow ``=` `i  ` ` `  `    ``# For last iteration. That is if array is  ` `    ``# traversed and fast > slow  ` `    ``if` `(fast !``=` `slow) :  ` `        ``length ``=` `fast ``-` `slow ``+` `1` `        ``result ``+``=` `length ``*` `(length ``-` `1``) ``/``/` `2``;  ` `     `  `    ``return` `result ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``5``, ``6``, ``7` `] ` `    ``n ``=` `len``(arr) ` ` `  `    ``print``(subarrayCount(arr, n)) ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# program to count Subarrays with ` `// Consecutive elements differing by 1 ` `using` `System; ` `class` `cfg  ` `{ ` ` `  `// Function to count Subarrays with ` `// Consecutive elements differing by 1 ` `static` `int` `subarrayCount(``int` `[]arr, ``int` `n) ` `{ ` `    ``// Variable to store count of subarrays ` `    ``// whose consecutive elements differ by 1 ` `    ``int` `result = 0; ` ` `  `    ``// Take two pointers for maintaining a ` `    ``// window of consecutive elements ` `    ``int` `fast = 0, slow = 0; ` ` `  `    ``// Traverse the array ` `    ``for` `(``int` `i = 1; i < n; i++) { ` ` `  `        ``// If elements differ by 1 ` `        ``// increment only the fast pointer ` `        ``if` `(arr[i] - arr[i - 1] == 1) { ` `            ``fast++; ` `        ``} ` `        ``else` `{ ` ` `  `            ``// Calculate length of subarray ` `            ``int` `len = fast - slow + 1; ` ` `  `            ``// Calculate total subarrays except  ` `            ``// Subarrays with single element ` `            ``result += len * (len - 1) / 2; ` ` `  `            ``// Update fast and slow ` `            ``fast = i; ` `            ``slow = i; ` `        ``} ` `    ``} ` ` `  `    ``// For last iteration. That is if array is ` `    ``// traversed and fast > slow ` `    ``if` `(fast != slow) { ` `        ``int` `len = fast - slow + 1; ` `        ``result += len * (len - 1) / 2; ` `    ``} ` ` `  `    ``return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` ` `  `    ``int` `[]arr = { 1, 2, 3, 5, 6, 7 }; ` `    ``int` `n = arr.Length; ` ` `  `    ``Console.WriteLine(subarrayCount(arr, n)); ` ` `  `} ` `} ` `//This code is contributed by inder_verma.. `

## PHP

 ` slow ` `    ``if` `(``\$fast` `!= ``\$slow``) ` `    ``{ ` `        ``\$len` `= ``\$fast` `- ``\$slow` `+ 1; ` `        ``\$result` `+= ``\$len` `* (``\$len` `- 1) / 2; ` `    ``} ` ` `  `    ``return` `\$result``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 3, 5, 6, 7); ` `\$n` `= sizeof(``\$arr``); ` ` `  `echo` `subarrayCount(``\$arr``, ``\$n``); ` ` `  `// This code is contributed  ` `// by Akanksha Rai ` `?> `

Output:

```6
```

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

My Personal Notes arrow_drop_up

Striver(underscore)79 at Codechef and codeforces D

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.