# Find the Longest subarray such that difference between adjacent elements is K

Last Updated : 31 Mar, 2022

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 =1
Output: {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 = 2
Output: {4, 6, 8}

Approach: Starting from the first element of the array, find the first valid sub-array and store its length and starting point. Then starting from the next element (the first element that wasnâ€™t included in the first sub-array), find another valid sub-array and keep on updating the maximum length and start point. Repeat the process until all the valid sub-arrays have been found then print the maximum length 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` `// sub-array such that the` `// absolute difference between every two` `// consecutive elements is K` `void` `getMaxLengthSubarray(``int` `arr[], ` `                          ``int` `N, ``int` `K)` `{` `    ``int` `l = N;` `    ``int` `i = 0, maxlen = 0;` `    ``int` `max_len_start, max_len_end;` `    ``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 subarray` `        ``if` `(maxlen < currLen) {` `            ``maxlen = currLen;` `            ``max_len_start = j;` `            ``max_len_end = i;` `        ``}`   `        ``if` `(j == i)` `            ``i++;` `    ``}`   `    ``// Print the maximum length subarray` `    ``for` `(``int` `p = max_len_start; ` `         ``p <= max_len_end; p++)` `        ``cout << arr[p] << ``" "``;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 4, 6, 8, 9, 8, 12, ` `                 ``14, 17, 15 };` `    ``int` `K = 2;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``getMaxLengthSubarray(arr, N, K);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `public` `class` `GFG` `{`   `// Function to return the maximum length` `// sub-array such that the` `// absolute difference between every two` `// consecutive elements is K` `static` `void` `getMaxLengthSubarray(``int` `arr[], ` `                          ``int` `N, ``int` `K)` `{` `    ``int` `l = N;` `    ``int` `i = ``0``, maxlen = ``0``;` `    ``int` `max_len_start = ``0``, max_len_end = ``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 subarray` `        ``if` `(maxlen < currLen) {` `            ``maxlen = currLen;` `            ``max_len_start = j;` `            ``max_len_end = i;` `        ``}`   `        ``if` `(j == i)` `            ``i++;` `    ``}`   `    ``// Print the maximum length subarray` `    ``for` `(``int` `p = max_len_start; ` `         ``p <= max_len_end; p++)` `        ``System.out.print(arr[p] + ``" "``);` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `arr[] = { ``4``, ``6``, ``8``, ``9``, ``8``, ``12``, ` `                 ``14``, ``17``, ``15` `};` `    ``int` `K = ``2``;` `    ``int` `N =  arr.length;  ` `    ``getMaxLengthSubarray(arr, N, K);` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python program to implement` `# the above approach`   `# Function to return the maximum length` `# sub-array such that the` `# absolute difference between every two` `# consecutive elements is K` `def` `getMaxLengthSubarray(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 subarray` `        ``if` `(maxlen < currLen) :` `            ``maxlen ``=` `currLen` `            ``max_len_start ``=` `j` `            ``max_len_end ``=` `i` `        `  `        ``if` `(j ``=``=` `i) :` `            ``i ``+``=` `1` `    `  `    ``# Print the maximum length subarray` `    ``for` `p ``in` `range``(max_len_start, max_len_end``+``1``, ``1``) :` `        ``print``(arr[p], end``=``" "``)`   `# Driver code` `arr ``=` `[ ``4``, ``6``, ``8``, ``9``, ``8``, ``12``, ` `                 ``14``, ``17``, ``15` `]` `K ``=` `2` `N ``=` `len``(arr)` `getMaxLengthSubarray(arr, N, K)`   `# This code is contributed by avijitmondal1998`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG` `{`   `// Function to return the maximum length` `// sub-array such that the` `// absolute difference between every two` `// consecutive elements is K` `static` `void` `getMaxLengthSubarray(``int` `[]arr, ` `                          ``int` `N, ``int` `K)` `{` `    ``int` `l = N;` `    ``int` `i = 0, maxlen = 0;` `    ``int` `max_len_start = 0, max_len_end = 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 subarray` `        ``if` `(maxlen < currLen) {` `            ``maxlen = currLen;` `            ``max_len_start = j;` `            ``max_len_end = i;` `        ``}`   `        ``if` `(j == i)` `            ``i++;` `    ``}`   `    ``// Print the maximum length subarray` `    ``for` `(``int` `p = max_len_start; ` `         ``p <= max_len_end; p++)` `        ``Console.Write(arr[p] + ``" "``);` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `[]arr = { 4, 6, 8, 9, 8, 12, ` `                 ``14, 17, 15 };` `    ``int` `K = 2;` `    ``int` `N =  arr.Length;  ` `    ``getMaxLengthSubarray(arr, N, K);` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`4 6 8 `

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

Article Tags :
Practice Tags :