Open In App

Length of Longest subarray such that difference between adjacent elements is K

Last Updated : 24 Jul, 2022
Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] of size N, and integer K. The task is to find the length of the longest subarray with the difference between adjacent elements as K.

Examples:

Input: arr[] = { 5, 5, 5, 10, 8, 6, 12, 13 }, K =1
Output: 2
Explanation: Only one subarray which have difference between adjacents as 1 is {12, 13}.

Input: arr[] = {4, 6, 8, 9, 8, 12, 14, 17, 15}, K = 2
Output: 3
Explanation: There are three such subarrays {4, 6, 8}, {12, 14} and {17, 15}.
{4, 6, 8} has the highest length.

Input: arr[] = {2, 2, 4, 6}, K = 1
Output: 1
Explanation: No subarray of length more than satisfies this criteria.

 

Approach: Starting from the first element of the array, find the first valid sub-array and store its length then starting from the next element (the first element that wasn’t included in the first sub-array), find another valid sub-array. Repeat the process until all the valid sub-arrays have been found then print the length of the longest sub-array.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum length
// of the sub-array such that the
// absolute difference between every two
// consecutive elements is K
int getMaxLength(int arr[], int N, int K)
{
    int l = N;
    int i = 0, maxlen = 0;
    while (i < l) {
        int j = i;
        while (i + 1 < l
               && (abs(arr[i] -
                       arr[i + 1]) == K)) {
            i++;
        }
 
        // Length of the valid sub-array
        // currently under consideration
        int currLen = i - j + 1;
 
        // Update the maximum length
        if (maxlen < currLen)
            maxlen = currLen;
 
        if (j == i)
            i++;
    }
 
    // Return the maximum possible length
    return maxlen;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 2, 4, 6 };
    int K = 1;
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << getMaxLength(arr, N, K);
    return 0;
}


Java




// Java program for the above approach
import java.util.*;
public class GFG
{
 
// Function to return the maximum length
// of the sub-array such that the
// absolute difference between every two
// consecutive elements is K
static int getMaxLength(int arr[], int N, int K)
{
    int l = N;
    int i = 0, maxlen = 0;
    while (i < l) {
        int j = i;
        while (i + 1 < l
               && (Math.abs(arr[i] -
                       arr[i + 1]) == K)) {
            i++;
        }
 
        // Length of the valid sub-array
        // currently under consideration
        int currLen = i - j + 1;
 
        // Update the maximum length
        if (maxlen < currLen)
            maxlen = currLen;
 
        if (j == i)
            i++;
    }
 
    // Return the maximum possible length
    return maxlen;
}
 
// Driver code
public static void main(String args[])
{
    int arr[] = { 2, 2, 4, 6 };
    int K = 1;
    int N =  arr.length; 
    System.out.print(getMaxLength(arr, N, K));
}
}
 
// This code is contributed by Samim Hossain Mondal.


Python3




# Python implementation of the approach
 
# Function to return the maximum length
# of the sub-array such that the
# absolute difference between every two
# consecutive elements is K
def getMaxLength (arr, N, K):
    l = N;
    i = 0
    maxlen = 0;
    while (i < l):
        j = i;
        while (i + 1 < l and (abs(arr[i] - arr[i + 1]) == K)):
            i += 1
 
        # Length of the valid sub-array
        # currently under consideration
        currLen = i - j + 1;
 
        # Update the maximum length
        if (maxlen < currLen):
            maxlen = currLen;
 
        if (j == i):
            i += 1
 
    # Return the maximum possible length
    return maxlen;
 
# Driver code
arr = [2, 2, 4, 6];
K = 1;
N = len(arr)
print(getMaxLength(arr, N, K));
 
# This code is contributed by gfgking


C#




// C# program for the above approach
using System;
class GFG
{
 
  // Function to return the maximum length
  // of the sub-array such that the
  // absolute difference between every two
  // consecutive elements is K
  static int getMaxLength(int []arr, int N, int K)
  {
    int l = N;
    int i = 0, maxlen = 0;
    while (i < l) {
      int j = i;
      while (i + 1 < l
             && (Math.Abs(arr[i] -
                          arr[i + 1]) == K)) {
        i++;
      }
 
      // Length of the valid sub-array
      // currently under consideration
      int currLen = i - j + 1;
 
      // Update the maximum length
      if (maxlen < currLen)
        maxlen = currLen;
 
      if (j == i)
        i++;
    }
 
    // Return the maximum possible length
    return maxlen;
  }
 
  // Driver Code
  public static void Main()
  {
    int []arr = { 2, 2, 4, 6 };
    int K = 1;
    int N =  arr.Length;
    Console.Write(getMaxLength(arr, N, K));
  }
}
 
// This code is contributed by Samim Hossain Mondal.


Javascript




<script>
    // JavaScript implementation of the approach
 
    // Function to return the maximum length
    // of the sub-array such that the
    // absolute difference between every two
    // consecutive elements is K
    const getMaxLength = (arr, N, K) => {
        let l = N;
        let i = 0, maxlen = 0;
        while (i < l) {
            let j = i;
            while (i + 1 < l
                && (Math.abs(arr[i] -
                    arr[i + 1]) == K)) {
                i++;
            }
 
            // Length of the valid sub-array
            // currently under consideration
            let currLen = i - j + 1;
 
            // Update the maximum length
            if (maxlen < currLen)
                maxlen = currLen;
 
            if (j == i)
                i++;
        }
 
        // Return the maximum possible length
        return maxlen;
    }
 
    // Driver code
    let arr = [2, 2, 4, 6];
    let K = 1;
    let N = arr.length;
    document.write(getMaxLength(arr, N, K));
 
// This code is contributed by rakeshsahni
 
</script>


 
 

Output

1

 

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

 



Similar Reads

Find the Longest subarray such that difference between adjacent elements is K
Given an array arr[] of size N, and integer K. The task is to find the longest subarray with the difference between adjacent elements as K. Examples: Input: arr[] = { 5, 5, 5, 10, 8, 6, 12, 13 }, K =1Output: {12, 13}Explanation: This is the longest subarray with difference between adjacents as 1. Input: arr[] = {4, 6, 8, 9, 8, 12, 14, 17, 15}, K =
6 min read
Length of longest non-decreasing subsequence such that difference between adjacent elements is at most one
Given an array arr[] consisting of N integers, the task is to find the length of the longest non-decreasing subsequence such that the difference between adjacent elements is at most 1. Examples: Input: arr[] = {8, 5, 4, 8, 4}Output: 3Explanation: {4, 4, 5}, {8, 8} are the two such non-decreasing subsequences of length 2 and 3 respectively. Therefor
6 min read
Longest subarray such that adjacent elements have at least one common digit | Set 1
Given an array of N integers, write a program that prints the length of the longest subarray such that adjacent elements of the subarray have at least one digit in common. Examples: Input : 12 23 45 43 36 97 Output : 3 Explanation: The subarray is 45 43 36 which has 4 common in 45, 43 and 3 common in 43, 36. Input : 11 22 33 44 54 56 63 Output : 4
11 min read
Longest subarray such that adjacent elements have at least one common digit | Set - 2
Given an array of N integers, the task is to find the length of the longest subarray such that adjacent elements of the subarray have at least one digit in common.Examples: Input : arr[] = {12, 23, 45, 43, 36, 97} Output : 3 Explanation: The subarray is 45 43 36 which has 4 common in 45, 43 and 3 common in 43, 36. Input : arr[] = {11, 22, 33, 44, 5
12 min read
Length of the longest increasing subsequence such that no two adjacent elements are coprime
Given an array arr[] of size N. The task is to find the length of the longest subsequence from the given array such that the sequence is strictly increasing and no two adjacent elements are coprime. Note: The elements in the given array are strictly increasing in order (1 &lt;= a[i] &lt;= 105) Examples: Input : a[] = { 1, 2, 3, 4, 5, 6} Output : 3
9 min read
Length of the longest subsequence such that xor of adjacent elements is non-decreasing
Given a sequence arr of N positive integers, the task is to find the length of the longest subsequence such that xor of adjacent integers in the subsequence must be non-decreasing. Examples: Input: N = 8, arr = {1, 100, 3, 64, 0, 5, 2, 15} Output: 6 The subsequence of maximum length is {1, 3, 0, 5, 2, 15} with XOR of adjacent elements as {2, 3, 5,
7 min read
Length of the longest subsequence such that XOR of adjacent elements is equal to K
Given an array arr[] of N non-negative integers and an integer K, the idea is to find the length of the longest subsequence having Xor of adjacent elements equal to K. Examples: Input: N = 5, arr[] = {3, 2, 4, 3, 5}, K = 1Output: 3Explanation:All the subsequences having Xor of adjacent element equal to K are {3, 2}, {2, 3}, {4, 5}, {3, 2, 3}.Theref
13 min read
Longest Subsequence such that difference between adjacent elements is either A or B
Given an array arr of size N, and two integers A and B. The task is to find the length of the longest subsequence with the difference between adjacent elements as either A or B. Example: Input : arr[]={ 5, 5, 5, 10, 8, 6, 12, 13 }, A=0, B=1Output : 4Explanation : Maximum length subsequence is {5,5,5,6} Input : arr[] = {4, 6, 7, 8, 9, 8, 12, 14, 17,
7 min read
Longest subsequence such that difference between adjacent elements is K
Given an array arr[] of size N and an integer K, the task is to find the longest subsequence such that the difference between adjacents is K. Example: Input: arr[]={1, 2, 3, 4, 5, 3, 2}, K=1Output: 6Explanation: The longest subsequence with the difference between the adjacent elements as 1 is: {1, 2, 3, 4, 3, 2} Input: arr[]={1, 2, 3, 2, 3, 7, 2, 1
5 min read
Print longest Subsequence such that difference between adjacent elements is K
Given an array arr[] of size N, and integer K. The task is to find the longest subsequence with the difference between adjacent elements as K Examples: Input: arr[] = { 5, 5, 5, 10, 8, 6, 12, 13 }, K = 1Output: {5, 6} Input: arr[] = {4, 6, 7, 8, 9, 8, 12, 14, 17, 15}, K = 2Output: {4, 6, 8} Approach: The task can be solved with the help of dynamic
9 min read
Article Tags :
Practice Tags :