Count Subarrays with Consecutive elements differing by 1 - GeeksforGeeks

07 May, 2021
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
 
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++
Java
Python3
C#
PHP
Javascript
// C++ program to count Subarrays with// Consecutive elements differing by 1 #include <iostream>using namespace std; // Function to count Subarrays with// Consecutive elements differing by 1int 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 Codeint main(){     int arr[] = { 1, 2, 3, 5, 6, 7 };    int n = sizeof(arr) / sizeof(arr[0]);     cout << subarrayCount(arr, n);     return 0;}
// Java program to count Subarrays with// Consecutive elements differing by 1class cfg{ // Function to count Subarrays with// Consecutive elements differing by 1static 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 Codepublic 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 program to count Subarrays with# Consecutive elements differing by 1 # Function to count Subarrays with# Consecutive elements differing by 1def 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 Codeif __name__ == "__main__" :     arr = [ 1, 2, 3, 5, 6, 7 ]    n = len(arr)     print(subarrayCount(arr, n)) # This code is contributed by Ryuga
// C# program to count Subarrays with// Consecutive elements differing by 1using System;class cfg{ // Function to count Subarrays with// Consecutive elements differing by 1static 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 Codepublic 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// PHP program to count Subarrays with// Consecutive elements differing by 1 // Function to count Subarrays with// Consecutive elements differing by 1function 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 = 0; $slow = 0;     // Traverse the array    for ($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            $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)    {        $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?>
<script> // Javascript program to count Subarrays with// Consecutive elements differing by 1      // Function to count Subarrays with    // Consecutive elements differing by 1    function subarrayCount(arr , n) {        // Variable to store count of subarrays        // whose consecutive elements differ by 1        var result = 0;         // Take two pointers for maintaining a        // window of consecutive elements        var fast = 0, slow = 0;         // Traverse the array        for (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                var 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) {            var len = fast - slow + 1;            result += len * (len - 1) / 2;        }         return result;    }     // Driver Code              var arr = [ 1, 2, 3, 5, 6, 7 ];        var n = arr.length;         document.write(subarrayCount(arr, n));  // This code contributed by aashish1995 </script>
6
 
Time Complexity: O(N) Auxiliary Space: (1) 
ankthon
Akanksha_Rai
Code_Mech
inderDuMCA
aashish1995
array-traversal-question
subarray
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Chocolate Distribution Problem
Reversal algorithm for array rotation
Window Sliding Technique
Next Greater Element
Find duplicates in O(n) time and O(1) extra space | Set 1
Count pairs with given sum
Remove duplicates from sorted array
Find subarray with given sum | Set 1 (Nonnegative Numbers)
Building Heap from Array
Move all negative numbers to beginning and positive to end with constant extra space