 GFG App
Open App Browser
Continue

# Length of 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 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 ` `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);` `    ``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

 ``

Output

`1`

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

My Personal Notes arrow_drop_up