Given an integer array **arr[]** of size **N**, the task is to find the longest subsequence **S** such that for every a[i], a[j] ∈ S and **|a[i] – a[j]| ≤ 1**.**Examples:**

Input:arr[] = {2, 2, 3, 5, 5, 6, 6, 6}Output:5Explanation:

There are 2 such subsequence such that difference between every pair is atmost 1

{2, 2, 3} and {5, 5, 6, 6, 6}

The longest one of these is {5, 5, 6, 6, 6} with length of 5.Input:arr[] = {5, 7, 6, 4, 4, 2}Output:3

**Approach:**

The idea is to observe that for a subsequence with difference between every possible pair atmost one is possible when the subsequence contains elements between [X , X + 1].

- Intialize the maximum length of required subsequence to 0.
- Create a HashMap to store frequency of every element of the array.
- Interate through the Hash Map and for every element a[i] in hash map –
- Find the count of occurrence of element (a[i] + 1), (a[i]) and (a[i] – 1).
- Find the Maximum count out of occurrence of elements (a[i] + 1) or (a[i] – 1).
- If the Total count of occurrence is greater than the maximum length found then update the maximum length of subsequence.

Below is the implementation of above approach.

## Java

`// Java implementation for` `// Longest subsequence such that absolute` `// difference between every pair is atmost 1` `import` `java.util.*;` `public` `class` `GeeksForGeeks {` ` ` `public` `static` `int` `longestAr(` ` ` `int` `n, ` `int` `arr[]){` ` ` `Hashtable<Integer, Integer> count` ` ` `= ` `new` `Hashtable<Integer, Integer>();` ` ` `// Storing the frequency of each` ` ` `// element in the hashtable count` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` `if` `(count.containsKey(arr[i]))` ` ` `count.put(arr[i], count.get(` ` ` `arr[i]) + ` `1` ` ` `);` ` ` `else` ` ` `count.put(arr[i], ` `1` `);` ` ` `}` ` ` `Set<Integer> kset = count.keySet();` ` ` `Iterator<Integer> it = kset.iterator();` ` ` `// Max is used to keep a track of` ` ` `// maximum length of the required` ` ` `// subsequence so far.` ` ` `int` `max = ` `0` `;` ` ` `while` `(it.hasNext()) {` ` ` `int` `a = (` `int` `)it.next();` ` ` `int` `cur = ` `0` `;` ` ` `int` `cur1 = ` `0` `;` ` ` `int` `cur2 = ` `0` `;` ` ` `// Store frequency of the` ` ` `// given element+1.` ` ` `if` `(count.containsKey(a + ` `1` `))` ` ` `cur1 = count.get(a + ` `1` `);` ` ` `// Store frequency of the` ` ` `// given element-1.` ` ` `if` `(count.containsKey(a - ` `1` `))` ` ` `cur2 = count.get(a - ` `1` `);` ` ` `// cur store the longest array` ` ` `// that can be formed using a.` ` ` `cur = count.get(a) +` ` ` `Math.max(cur1, cur2);` ` ` `// update max if cur>max.` ` ` `if` `(cur > max)` ` ` `max = cur;` ` ` `}` ` ` `return` `(max);` ` ` `}` ` ` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `n = ` `8` `;` ` ` `int` `arr[] = { ` `2` `, ` `2` `, ` `3` `, ` `5` `, ` `5` `, ` `6` `, ` `6` `, ` `6` `};` ` ` `int` `maxLen = longestAr(n, arr);` ` ` `System.out.println(maxLen);` ` ` `}` `}` |

## Python3

`# Python3 implementation for` `# Longest subsequence such that absolute` `# difference between every pair is atmost 1` `def` `longestAr(n, arr):` ` ` `count ` `=` `dict` `()` ` ` `# Storing the frequency of each` ` ` `# element in the hashtable count` ` ` `for` `i ` `in` `arr:` ` ` `count[i] ` `=` `count.get(i, ` `0` `) ` `+` `1` ` ` `kset ` `=` `count.keys()` ` ` `# Max is used to keep a track of` ` ` `# maximum length of the required` ` ` `# subsequence so far.` ` ` `maxm ` `=` `0` ` ` `for` `it ` `in` `list` `(kset):` ` ` `a ` `=` `it` ` ` `cur ` `=` `0` ` ` `cur1 ` `=` `0` ` ` `cur2 ` `=` `0` ` ` `# Store frequency of the` ` ` `# given element+1.` ` ` `if` `((a ` `+` `1` `) ` `in` `count):` ` ` `cur1 ` `=` `count[a ` `+` `1` `]` ` ` `# Store frequency of the` ` ` `# given element-1.` ` ` `if` `((a ` `-` `1` `) ` `in` `count):` ` ` `cur2 ` `=` `count[a ` `-` `1` `]` ` ` `# cur store the longest array` ` ` `# that can be formed using a.` ` ` `cur ` `=` `count[a] ` `+` `max` `(cur1, cur2)` ` ` `# update maxm if cur>maxm.` ` ` `if` `(cur > maxm):` ` ` `maxm ` `=` `cur` ` ` `return` `maxm` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `n ` `=` `8` ` ` `arr ` `=` `[` `2` `, ` `2` `, ` `3` `, ` `5` `, ` `5` `, ` `6` `, ` `6` `, ` `6` `]` ` ` `maxLen ` `=` `longestAr(n, arr)` ` ` `print` `(maxLen)` `# This code is contributed by mohit kumar 29` |

## Javascript

`<script>` `// Javascript implementation for` `// Longest subsequence such that absolute` `// difference between every pair is atmost 1` `function` `longestAr(n,arr)` `{` ` ` `let count = ` `new` `Map();` ` ` ` ` `// Storing the frequency of each` ` ` `// element in the hashtable count` ` ` `for` `(let i = 0; i < n; i++) {` ` ` `if` `(count.has(arr[i]))` ` ` `count.set(arr[i], count.get(` ` ` `arr[i]) + 1` ` ` `);` ` ` `else` ` ` `count.set(arr[i], 1);` ` ` `}` ` ` ` ` ` ` ` ` `// Max is used to keep a track of` ` ` `// maximum length of the required` ` ` `// subsequence so far.` ` ` `let max = 0;` ` ` ` ` `for` `(let it of count.keys()) {` ` ` `let a = it;` ` ` `let cur = 0;` ` ` `let cur1 = 0;` ` ` `let cur2 = 0;` ` ` ` ` `// Store frequency of the` ` ` `// given element+1.` ` ` `if` `(count.has(a + 1))` ` ` `cur1 = count.get(a + 1);` ` ` ` ` `// Store frequency of the` ` ` `// given element-1.` ` ` `if` `(count.has(a - 1))` ` ` `cur2 = count.get(a - 1);` ` ` ` ` `// cur store the longest array` ` ` `// that can be formed using a.` ` ` `cur = count.get(a) +` ` ` `Math.max(cur1, cur2);` ` ` ` ` `// update max if cur>max.` ` ` `if` `(cur > max)` ` ` `max = cur;` ` ` `}` ` ` ` ` `return` `(max);` `}` `// Driver Code` `let n = 8;` `let arr=[2, 2, 3, 5, 5, 6, 6, 6];` `let maxLen = longestAr(n, arr);` `document.write(maxLen);` ` ` `// This code is contributed by unknown2108` `</script>` |

**Output:**

5

**Time Complexity:** O(n). **Space Complexity:** O(n).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**