Count Subarrays with Consecutive elements differing by 1
Last Updated :
16 Mar, 2023
Given an array arr[] of N integers. The task is to count the total number of subarrays of the given array such that the difference between the consecutive elements in the subarrays is one. That is, for any index i in the subarrays, arr[i+1] - arr[i] = 1.
Note: Do not consider subarrays with a 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.
C++
#include <iostream>
using namespace std;
int countSubarrays(int arr[], int n) {
int count = 0; // Initialize count to 0
// Loop over all subarrays
for (int i = 0; i < n; i++) {
int j = i + 1;
// Check if consecutive elements differ by 1
while (j < n && arr[j] - arr[j-1] == 1) {
j++;
}
// Add the count of subarrays with consecutive elements differing by 1
count += (j - i) * (j - i - 1) / 2;
// Move i to the next position
i = j - 1;
}
// Return the total count of subarrays
return count;
}
int main() {
int arr[] = {1, 2, 3};
int n = sizeof(arr)/sizeof(arr[0]);
int count = countSubarrays(arr, n);
cout << "Total number of subarrays with consecutive elements differing by 1: " << count << endl;
return 0;
}
// This code is contributed by Naveen Gujjar.
Java
import java.util.*;
public class Main {
public static int countSubarrays(int[] arr, int n) {
int count = 0; // Initialize count to 0
// Loop over all subarrays
for (int i = 0; i < n; i++) {
int j = i + 1;
// Check if consecutive elements differ by 1
while (j < n && arr[j] - arr[j-1] == 1) {
j++;
}
// Add the count of subarrays with consecutive elements differing by 1
count += (j - i) * (j - i - 1) / 2;
// Move i to the next position
i = j - 1;
}
// Return the total count of subarrays
return count;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int n = arr.length;
int count = countSubarrays(arr, n);
System.out.println("Total number of subarrays with consecutive elements differing by 1: " + count);
}
}
Python3
def countSubarrays(arr, n):
count = 0 # Initialize count to 0
# Loop over all subarrays
i = 0
while i < n:
j = i + 1
# Check if consecutive elements differ by 1
while j < n and arr[j] - arr[j-1] == 1:
j += 1
# Add the count of subarrays with consecutive elements differing by 1
count += (j - i) * (j - i - 1) // 2
# Move i to the next position
i = j
# Return the total count of subarrays
return count
arr = [1, 2, 3]
n = len(arr)
count = countSubarrays(arr, n)
print("Total number of subarrays with consecutive elements differing by 1:", count)
C#
using System;
class Gfg
{
static int countSubarrays(int[] arr, int n)
{
int count = 0; // Initialize count to 0
// Loop over all subarrays
for (int i = 0; i < n; i++) {
int j = i + 1;
// Check if consecutive elements differ by 1
while (j < n && arr[j] - arr[j-1] == 1) {
j++;
}
// Add the count of subarrays with consecutive elements differing by 1
count += (j - i) * (j - i - 1) / 2;
// Move i to the next position
i = j - 1;
}
// Return the total count of subarrays
return count;
}
public static void Main()
{
int[] arr = {1, 2, 3};
int n = arr.Length;
int count = countSubarrays(arr, n);
Console.WriteLine("Total number of subarrays with consecutive elements differing by 1: " + count);
}
}
JavaScript
function countSubarrays(arr, n) {
let count = 0; // Initialize count to 0
// Loop over all subarrays
for (let i = 0; i < n; i++) {
let j = i + 1;
// Check if consecutive elements differ by 1
while (j < n && arr[j] - arr[j - 1] === 1) {
j++;
}
// Add the count of subarrays with consecutive elements differing by 1
count += ((j - i) * (j - i - 1)) / 2;
// Move i to the next position
i = j - 1;
}
// Return the total count of subarrays
return count;
}
const arr = [1, 2, 3];
const n = arr.length;
const count = countSubarrays(arr, n);
console.log(
`Total number of subarrays with consecutive elements differing by 1: ${count}`
);
OutputTotal number of subarrays with consecutive elements differing by 1: 3
Time Complexity: O(N²)
Auxiliary Space: O(1)
Efficient Approach: An efficient approach is to observe that in an array of length say K, the 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 to 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 the 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 <iostream>
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
<?php
// PHP 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
$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
?>
JavaScript
<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>
Complexity Analysis:
- Time Complexity: O(N), as we are using a loop to traverse N times so the complexity for the program will be O(N).
- Auxiliary Space: O(1), as we are not using any extra space.
Similar Reads
Count Subarrays with strictly decreasing consecutive elements Given an array arr[] containing integers. The task is to find the number of decreasing subarrays with a difference of 1. Examples: Input: arr[] = {3, 2, 1, 4}Output: 7Explanation: Following are the possible decreasing subarrays with difference 1. [3], [2], [1], [4], [3,2], [2,1], and [3,2,1]Therefor
7 min read
Count of arrays having consecutive element with different values Given three positive integers n, k and x. The task is to count the number of different array that can be formed of size n such that each element is between 1 to k and two consecutive element are different. Also, the first and last elements of each array should be 1 and x respectively. Examples : Inp
10 min read
Count Subarrays With At Most K Distinct Elements Given an array arr[] of integers and a positive integer k, the goal is to count the total number of subarrays that contain at most k distinct (unique) elements.Examples:Input: arr[] = [1, 2, 2, 3], k = 2 Output: 9Explanation: Subarrays with at most 2 distinct elements are: [1], [2], [2], [3], [1, 2]
9 min read
Count consecutive pairs of same elements Given an array arr[], the task is to count the number of pairs formed by consecutive elements in which both of the elements in a pair are same.Examples: Input: arr[] = {1, 2, 2, 3, 4, 4, 5, 5, 5, 5} Output: 5 (1, 2), (4, 5), (6, 7), (7, 8) and (8, 9) are the valid index pairs where consecutive eleme
4 min read
Construct an Array having K Subarrays with all distinct elements Given integers N and K, the task is to construct an array arr[] of size N using numbers in the range [1, N] such that it has K sub-arrays whose all the elements are distinct. Note: If there are multiple possible answers return any of them. Examples: Input: N = 5, K = 8Output: {1, 2, 3, 3, 3}Explanat
7 min read
Count Subarrays With Exactly K Distinct Elements Given an array arr[] and an integer k, the task is to find the count of subarrays such that each subarray has exactly k distinct elements.Examples:Input: arr[] = [1, 2, 2, 3], k = 2 Output: 4 Explanation: Subarrays with exactly 2 distinct elements are: [1, 2], [1, 2, 2] and [2, 3].Input: arr[] = [3,
10 min read