# Longest Consecutive Subsequence

• Difficulty Level : Medium
• Last Updated : 21 Jun, 2022

Given an array of integers, find the length of the longest sub-sequence such that elements in the subsequence are consecutive integers, the consecutive numbers can be in any order.

Examples:

```Input: arr[] = {1, 9, 3, 10, 4, 20, 2}
Output: 4
Explanation:
The subsequence 1, 3, 4, 2 is the longest
subsequence of consecutive elements

Input: arr[] = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}
Output: 5
Explanation:
The subsequence 36, 35, 33, 34, 32 is the longest
subsequence of consecutive elements.```

Naive Approach: The idea is to first sort the array and find the longest subarray with consecutive elements.
After sorting the array and removing the multiple occurrences of elements, run a loop and keep a count and max (both initially zero). Run a loop from start to end and if the current element is not equal to the previous (element+1) then set the count to 1 else increase the count. Update max with a maximum of count and max. ## C++

 `// C++ program to find longest``// contiguous subsequence``#include ``using` `namespace` `std;`` ` `// Returns length of the longest``// contiguous subsequence``int` `findLongestConseqSubseq(``int` `arr[], ``int` `n)``{``    ``int` `ans = 0, count = 0;`` ` `    ``// sort the array``    ``sort(arr, arr + n);`` ` `    ``vector<``int``> v;``    ``v.push_back(arr);`` ` `    ``//insert repeated elements only once in the vector``    ``for` `(``int` `i = 1; i < n; i++) ``    ``{``        ``if` `(arr[i] != arr[i - 1])``            ``v.push_back(arr[i]);``    ``}``    ``// find the maximum length``    ``// by traversing the array``    ``for` `(``int` `i = 0; i < v.size(); i++) ``    ``{``         ` `        ``// Check if the current element is equal``        ``// to previous element +1``        ``if` `(i > 0 && v[i] == v[i - 1] + 1)``            ``count++;``        ``// reset the count``        ``else``            ``count = 1;`` ` `        ``// update the maximum``        ``ans = max(ans, count);``    ``}``    ``return` `ans;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 2, 3 };``    ``int` `n = ``sizeof` `arr / ``sizeof` `arr;``    ``cout << ``"Length of the Longest contiguous subsequence "``            ``"is "``         ``<< findLongestConseqSubseq(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to find longest``// contiguous subsequence``import` `java.io.*;``import` `java.util.*;`` ` `class` `GFG ``{`` ` `    ``static` `int` `findLongestConseqSubseq(``int` `arr[], ``                                           ``int` `n)``    ``{`` ` `        ``// Sort the array``        ``Arrays.sort(arr);`` ` `        ``int` `ans = ``0``, count = ``0``;``       ` `        ``ArrayList v = ``new` `ArrayList();``        ``v.add(``10``);``       ` `        ``// Insert repeated elements ``        ``// only once in the vector``        ``for` `(``int` `i = ``1``; i < n; i++) ``        ``{``            ``if` `(arr[i] != arr[i - ``1``])``                ``v.add(arr[i]);``        ``}``    ` ` ` `        ``// Find the maximum length``        ``// by traversing the array``        ``for` `(``int` `i = ``0``; i < v.size(); i++) ``        ``{`` ` `            ``// Check if the current element is``            ``// equal to previous element +1``            ``if` `(i > ``0` `&&v.get(i) == v.get(i - ``1``) + ``1``)``                ``count++;``            ``else``                ``count = ``1``;`` ` `            ``// Update the maximum``            ``ans = Math.max(ans, count);``        ``}``        ``return` `ans;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``9``, ``3``, ``10``, ``4``, ``20``, ``2` `};``        ``int` `n = arr.length;`` ` `        ``System.out.println(``            ``"Length of the Longest "``            ``+ ``"contiguous subsequence is "``            ``+ findLongestConseqSubseq(arr, n));``    ``}``}`` ` `// This code is contributed by parascoding`

## Python3

 `# Python3 program to find longest ``# contiguous subsequence `` ` `# Returns length of the longest ``# contiguous subsequence ``def` `findLongestConseqSubseq(arr, n):``     ` `    ``ans ``=` `0``    ``count ``=` `0`` ` `    ``# Sort the array ``    ``arr.sort()`` ` `    ``v ``=` `[]`` ` `    ``v.append(arr[``0``])`` ` `    ``# Insert repeated elements only ``    ``# once in the vector ``    ``for` `i ``in` `range``(``1``, n):``        ``if` `(arr[i] !``=` `arr[i ``-` `1``]):``            ``v.append(arr[i])`` ` `    ``# Find the maximum length ``    ``# by traversing the array ``    ``for` `i ``in` `range``(``len``(v)):`` ` `        ``# Check if the current element is``        ``# equal to previous element +1 ``        ``if` `(i > ``0` `and` `v[i] ``=``=` `v[i ``-` `1``] ``+` `1``):``            ``count ``+``=` `1``             ` `        ``# Reset the count ``        ``else``:``            ``count ``=` `1``             ` `        ``# Update the maximum ``        ``ans ``=` `max``(ans, count)``         ` `    ``return` `ans`` ` `# Driver code ``arr ``=` `[ ``1``, ``2``, ``2``, ``3` `]``n ``=` `len``(arr)`` ` `print``(``"Length of the Longest contiguous subsequence is"``,``       ``findLongestConseqSubseq(arr, n))`` ` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to find longest``// contiguous subsequence``using` `System;``using` `System.Collections.Generic; `` ` `class` `GFG{``     ` `static` `int` `findLongestConseqSubseq(``int``[] arr,``                                   ``int` `n)``{``     ` `    ``// Sort the array``    ``Array.Sort(arr);`` ` `    ``int` `ans = 0, count = 0;``    ` `    ``List<``int``> v = ``new` `List<``int``>(); ``    ``v.Add(10);``    ` `    ``// Insert repeated elements ``    ``// only once in the vector``    ``for``(``int` `i = 1; i < n; i++) ``    ``{``        ``if` `(arr[i] != arr[i - 1])``            ``v.Add(arr[i]);``    ``}``     ` `    ``// Find the maximum length``    ``// by traversing the array``    ``for``(``int` `i = 0; i < v.Count; i++) ``    ``{``         ` `        ``// Check if the current element is``        ``// equal to previous element +1``        ``if` `(i > 0 && v[i] == v[i - 1] + 1)``            ``count++;``        ``else``            ``count = 1;`` ` `        ``// Update the maximum``        ``ans = Math.Max(ans, count);``    ``}``    ``return` `ans;``}`` ` `// Driver code ``static` `void` `Main()``{``    ``int``[] arr = { 1, 9, 3, 10, 4, 20, 2 };``    ``int` `n = arr.Length;`` ` `    ``Console.WriteLine(``"Length of the Longest "` `+ ``                      ``"contiguous subsequence is "` `+``                      ``findLongestConseqSubseq(arr, n));``}``}`` ` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output

`Length of the Longest contiguous subsequence is 3`

Complexity Analysis:

• Time complexity: O(nLogn).
Time to sort the array is O(nlogn).
• Auxiliary space : O(1).
As no extra space is needed.

Thanks to Hao.W for suggesting the above solution.

Efficient solution:
This problem can be solved in O(n) time using an Efficient Solution. The idea is to use Hashing. We first insert all elements in a Set. Then check all the possible starts of consecutive subsequences.

Algorithm:

1. Create an empty hash.
2. Insert all array elements to hash.
3. Do following for every element arr[i]
4. Check if this element is the starting point of a subsequence. To check this, simply look for arr[i] – 1 in the hash, if not found, then this is the first element a subsequence.
5. If this element is the first element, then count the number of elements in the consecutive starting with this element. Iterate from arr[i] + 1 till the last element that can be found.
6. If the count is more than the previous longest subsequence found, then update this.

Below image is a dry run of the above approach: Below is the implementation of the above approach:

## C++

 `// C++ program to find longest``// contiguous subsequence``#include ``using` `namespace` `std;`` ` `// Returns length of the longest``// contiguous subsequence``int` `findLongestConseqSubseq(``int` `arr[], ``int` `n)``{``    ``unordered_set<``int``> S;``    ``int` `ans = 0;`` ` `    ``// Hash all the array elements``    ``for` `(``int` `i = 0; i < n; i++)``        ``S.insert(arr[i]);`` ` `    ``// check each possible sequence from``    ``// the start then update optimal length``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// if current element is the starting``        ``// element of a sequence``        ``if` `(S.find(arr[i] - 1) == S.end())``        ``{``            ``// Then check for next elements``            ``// in the sequence``            ``int` `j = arr[i];``            ``while` `(S.find(j) != S.end())``                ``j++;`` ` `            ``// update  optimal length if``            ``// this length is more``            ``ans = max(ans, j - arr[i]);``        ``}``    ``}``    ``return` `ans;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 9, 3, 10, 4, 20, 2 };``    ``int` `n = ``sizeof` `arr / ``sizeof` `arr;``    ``cout << ``"Length of the Longest contiguous subsequence "``            ``"is "``         ``<< findLongestConseqSubseq(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to find longest``// consecutive subsequence``import` `java.io.*;``import` `java.util.*;`` ` `class` `ArrayElements {``    ``// Returns length of the longest``    ``// consecutive subsequence``    ``static` `int` `findLongestConseqSubseq(``int` `arr[], ``int` `n)``    ``{``        ``HashSet S = ``new` `HashSet();``        ``int` `ans = ``0``;`` ` `        ``// Hash all the array elements``        ``for` `(``int` `i = ``0``; i < n; ++i)``            ``S.add(arr[i]);`` ` `        ``// check each possible sequence from the start``        ``// then update optimal length``        ``for` `(``int` `i = ``0``; i < n; ++i) ``        ``{``            ``// if current element is the starting``            ``// element of a sequence``            ``if` `(!S.contains(arr[i] - ``1``)) ``            ``{``                ``// Then check for next elements``                ``// in the sequence``                ``int` `j = arr[i];``                ``while` `(S.contains(j))``                    ``j++;`` ` `                ``// update  optimal length if this``                ``// length is more``                ``if` `(ans < j - arr[i])``                    ``ans = j - arr[i];``            ``}``        ``}``        ``return` `ans;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``1``, ``9``, ``3``, ``10``, ``4``, ``20``, ``2` `};``        ``int` `n = arr.length;``        ``System.out.println(``            ``"Length of the Longest consecutive subsequence is "``            ``+ findLongestConseqSubseq(arr, n));``    ``}``}``// This code is contributed by Aakash Hasija`

## Python3

 `# Python program to find longest contiguous subsequence`` ` ` ` `def` `findLongestConseqSubseq(arr, n):`` ` `    ``s ``=` `set``()``    ``ans ``=` `0`` ` `    ``# Hash all the array elements``    ``for` `ele ``in` `arr:``        ``s.add(ele)`` ` `    ``# check each possible sequence from the start``    ``# then update optimal length``    ``for` `i ``in` `range``(n):`` ` `         ``# if current element is the starting``        ``# element of a sequence``        ``if` `(arr[i]``-``1``) ``not` `in` `s:`` ` `            ``# Then check for next elements in the``            ``# sequence``            ``j ``=` `arr[i]``            ``while``(j ``in` `s):``                ``j ``+``=` `1`` ` `            ``# update  optimal length if this length``            ``# is more``            ``ans ``=` `max``(ans, j``-``arr[i])``    ``return` `ans`` ` ` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `7``    ``arr ``=` `[``1``, ``9``, ``3``, ``10``, ``4``, ``20``, ``2``]``    ``print` `(``"Length of the Longest contiguous subsequence is "``,findLongestConseqSubseq(arr, n))`` ` `# Contributed by: Harshit Sidhwa`

## C#

 `using` `System;``using` `System.Collections.Generic;`` ` `// C# program to find longest consecutive subsequence`` ` `public` `class` `ArrayElements {``    ``// Returns length of the ``    ``// longest consecutive subsequence``    ``public` `static` `int` `findLongestConseqSubseq(``int``[] arr,``                                              ``int` `n)``    ``{``        ``HashSet<``int``> S = ``new` `HashSet<``int``>();``        ``int` `ans = 0;`` ` `        ``// Hash all the array elements``        ``for` `(``int` `i = 0; i < n; ++i) {``            ``S.Add(arr[i]);``        ``}`` ` `        ``// check each possible sequence from the start``        ``// then update optimal length``        ``for` `(``int` `i = 0; i < n; ++i) ``        ``{``            ``// if current element is the starting``            ``// element of a sequence``            ``if` `(!S.Contains(arr[i] - 1)) ``            ``{``                ``// Then check for next elements in the``                ``// sequence``                ``int` `j = arr[i];``                ``while` `(S.Contains(j)) ``                ``{``                    ``j++;``                ``}`` ` `                ``// update  optimal length if this length``                ``// is more``                ``if` `(ans < j - arr[i]) ``                ``{``                    ``ans = j - arr[i];``                ``}``            ``}``        ``}``        ``return` `ans;``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] arr = ``new` `int``[] { 1, 9, 3, 10, 4, 20, 2 };``        ``int` `n = arr.Length;``        ``Console.WriteLine(``            ``"Length of the Longest consecutive subsequence is "``            ``+ findLongestConseqSubseq(arr, n));``    ``}``}`` ` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`Length of the Longest contiguous subsequence is 4`

Complexity Analysis:

• Time complexity: O(n).
Only one traversal is needed and the time complexity is O(n) under the assumption that hash insert and search take O(1) time.
• Auxiliary space: O(n).
To store every element in hashmap O(n) space is needed
Thanks to Gaurav Ahirwar for the above solution.

Another Solution:

This problem can be solved in O(N log N) time with another Method, this time the Idea is to use Priority Queue.

Algorithm:

1. Create a Priority Queue to store the element
2. Store the first element in a variable
3. Remove it from the Priority Queue
4. Check the difference between this removed first element and the new peek element
5. If the difference is equal to 1 increase count by 1 and repeats step 2 and step 3
6. If the difference is greater than 1 set counter to 1 and repeat step 2 and step 3
7. if the difference is equal to 0 repeat step 2 and 3
8. if counter greater than the previous maximum then store counter to maximum
9. Continue step 4 to 7 until we reach the end of the Priority Queue
10. Return the maximum value

## C++

 `// CPP program for the above approach``#include ``using` `namespace` `std;`` ` `int` `findLongestConseqSubseq(``int` `arr[], ``int` `N)``{``    ``priority_queue<``int``, vector<``int``>, greater<``int``> > pq;``    ``for` `(``int` `i = 0; i < N; i++) {``       ` `        ``// adding element from``        ``// array to PriorityQueue``        ``pq.push(arr[i]);``    ``}`` ` `    ``// Storing the first element``    ``// of the Priority Queue``    ``// This first element is also``    ``// the smallest element``    ``int` `prev = pq.top();``    ``pq.pop();`` ` `    ``// Taking a counter variable with value 1``    ``int` `c = 1;`` ` `    ``// Storing value of max as 1``    ``// as there will always be``    ``// one element``    ``int` `max = 1;``    ``while` `(!pq.empty()) {``       ` `        ``// check if current peek``        ``// element minus previous``        ``// element is greater then``        ``// 1 This is done because``        ``// if it's greater than 1``        ``// then the sequence``        ``// doesn't start or is broken here``        ``if` `(pq.top() - prev > 1) {``           ` `            ``// Store the value of counter to 1``            ``// As new sequence may begin``            ``c = 1;`` ` `            ``// Update the previous position with the``            ``// current peek And remove it``            ``prev = pq.top();``            ``pq.pop();``        ``}`` ` `        ``// Check if the previous``        ``//  element and peek are same``        ``else` `if` `(pq.top() - prev == 0) {``           ` `            ``// Update the previous position with the``            ``// current peek And remove it``            ``prev = pq.top();``            ``pq.pop();``        ``}``       ` `        ``// If the difference``        ``// between previous element and peek is 1``        ``else` `{``           ` `            ``// Update the counter``            ``// These are consecutive elements``            ``c++;`` ` `            ``// Update the previous position``            ``//  with the current peek And remove it``            ``prev = pq.top();``            ``pq.pop();``        ``}``       ` `        ``// Check if current longest``        ``// subsequence is the greatest``        ``if` `(max < c) {``           ` `            ``// Store the current subsequence count as``            ``// max``            ``max = c;``        ``}``    ``}``    ``return` `max;``}`` ` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 9, 3, 10, 4, 20, 2 };``    ``int` `n = 7;`` ` `    ``cout << ``"Length of the Longest consecutive subsequence "``            ``"is "``         ``<< findLongestConseqSubseq(arr, n);``    ``return` `0;``}``// this code is contributed by Manu Pathria`

## Java

 `// Java Program to find longest consecutive ``// subsequence This Program uses Priority Queue``import` `java.io.*;``import` `java.util.PriorityQueue;``public` `class` `Longset_Sub``{``    ``// return the length of the longest``    ``// subsequence of consecutive integers``    ``static` `int` `findLongestConseqSubseq(``int` `arr[], ``int` `N)``    ``{`` ` `        ``PriorityQueue pq``            ``= ``new` `PriorityQueue();``        ``for` `(``int` `i = ``0``; i < N; i++) ``        ``{``            ``// adding element from ``            ``// array to PriorityQueue``            ``pq.add(arr[i]);``        ``}``         ` `        ``// Storing the first element ``        ``// of the Priority Queue``        ``// This first element is also ``        ``// the smallest element``        ``int` `prev = pq.poll();``         ` `        ``// Taking a counter variable with value 1``        ``int` `c = ``1``;``         ` `        ``// Storing value of max as 1``        ``// as there will always be``        ``// one element``        ``int` `max = ``1``;`` ` `        ``for` `(``int` `i = ``1``; i < N; i++) ``        ``{``            ``// check if current peek ``            ``// element minus previous``            ``// element is greater then ``            ``// 1 This is done because``            ``// if it's greater than 1 ``            ``// then the sequence``            ``// doesn't start or is broken here``            ``if` `(pq.peek() - prev > ``1``) ``            ``{``                ``// Store the value of counter to 1``                ``// As new sequence may begin``                ``c = ``1``;``                 ` `                ``// Update the previous position with the``                ``// current peek And remove it``                ``prev = pq.poll();``            ``}``             ` `            ``// Check if the previous``            ``//  element and peek are same``            ``else` `if` `(pq.peek() - prev == ``0``) ``            ``{``                ``// Update the previous position with the``                ``// current peek And remove it``                ``prev = pq.poll();``            ``}``            ``// if the difference ``            ``// between previous element and peek is 1``            ``else` `            ``{``                ``// Update the counter``                ``// These are consecutive elements``                ``c++;``                  ` `                ``// Update the previous position``                ``//  with the current peek And remove it``                ``prev = pq.poll();``            ``}`` ` `            ``// Check if current longest ``            ``// subsequence is the greatest``            ``if` `(max < c) ``            ``{``                ``// Store the current subsequence count as``                ``// max``                ``max = c;``            ``}``        ``}`` ` `        ``return` `max;``    ``}``     ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``        ``throws` `IOException``    ``{``        ``int` `arr[] = { ``1``, ``9``, ``3``, ``10``, ``4``, ``20``, ``2` `};``        ``int` `n = arr.length;``        ``System.out.println(``            ``"Length of the Longest consecutive subsequence is "``            ``+ findLongestConseqSubseq(arr, n));``    ``}``}``// This code is contributed by Sudipa Sarkar`

## Python3

 `# Python program for the above approach``import` `bisect`` ` `def` `findLongestConseqSubseq(arr,N):``    ``pq ``=` `[]``    ``for` `i ``in` `range``(N):``       ` `        ``# adding element from``        ``# array to PriorityQueue``        ``bisect.insort(pq,arr[i])``         ` `    ``# Storing the first element``    ``# of the Priority Queue``    ``# This first element is also``    ``# the smallest element``    ``prev ``=` `pq[``0``]``    ``pq.pop(``0``)``     ` `    ``# Taking a counter variable with value 1``    ``c``=``1``     ` `    ``# Storing value of max as 1``    ``# as there will always be``    ``# one element``    ``max` `=` `1``    ``while``(``len``(pq)):``        ``# check if current peek``        ``# element minus previous``        ``# element is greater then``        ``# 1 This is done because``        ``# if it's greater than 1``        ``# then the sequence``        ``# doesn't start or is broken here``        ``if``(pq[``0``] ``-` `prev > ``1``):``            ``# Store the value of counter to 1``            ``# As new sequence may begin``            ``c ``=` `1``             ` `            ``# Update the previous position with the``            ``# current peek And remove it``            ``prev ``=` `pq[``0``]``            ``pq.pop(``0``)``             ` `        ``# Check if the previous``        ``# element and peek are same``        ``elif``(pq[``0``] ``-` `prev ``=``=` `0``):``            ``# Update the previous position with the``            ``# current peek And remove it``            ``prev ``=` `pq[``0``]``            ``pq.pop(``0``)``             ` `        ``# If the difference``        ``# between previous element and peek is 1``        ``else``:``            ``# Update the counter``            ``# These are consecutive elements``            ``c ``=` `c ``+``1``            ``# Update the previous position``            ``# with the current peek And remove it``            ``prev ``=` `pq[``0``]``            ``pq.pop(``0``)``             ` `        ``# Check if current longest``        ``# subsequence is the greatest``        ``if``(``max` `< c):``            ``# Store the current subsequence count as``            ``# max``            ``max` `=` `c``    ``return` `max`` ` `# Driver Code``arr ``=` `[``1``, ``9``, ``3``, ``10``, ``4``, ``20``, ``2``]``n ``=` `7``print``(``"Length of the Longest consecutive subsequence is {}"``.``format``(findLongestConseqSubseq(arr, n)))`` ` ` ` `# This code is contributed by Pushpesh Raj`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{`` ` `  ``// return the length of the longest``  ``// subsequence of consecutive integers``  ``static` `int` `findLongestConseqSubseq(``int``[] arr, ``int` `N)``  ``{`` ` `    ``List<``int``> pq = ``new` `List<``int``>();``    ``for` `(``int` `i = 0; i < N; i++)``    ``{`` ` `      ``// adding element from``      ``// array to PriorityQueue``      ``pq.Add(arr[i]);``      ``pq.Sort();``    ``}`` ` `    ``// Storing the first element``    ``// of the Priority Queue``    ``// This first element is also``    ``// the smallest element``    ``int` `prev = pq;`` ` `    ``// Taking a counter variable with value 1``    ``int` `c = 1;`` ` `    ``// Storing value of max as 1``    ``// as there will always be``    ``// one element``    ``int` `max = 1;`` ` `    ``for` `(``int` `i = 1; i < N; i++)``    ``{`` ` `      ``// check if current peek``      ``// element minus previous``      ``// element is greater then``      ``// 1 This is done because``      ``// if it's greater than 1``      ``// then the sequence``      ``// doesn't start or is broken here``      ``if` `(pq - prev > 1)``      ``{``        ``// Store the value of counter to 1``        ``// As new sequence may begin``        ``c = 1;`` ` `        ``// Update the previous position with the``        ``// current peek And remove it``        ``prev = pq;``        ``pq.RemoveAt(0);``      ``}`` ` `      ``// Check if the previous``      ``//  element and peek are same``      ``else` `if` `(pq - prev == 0)``      ``{`` ` `        ``// Update the previous position with the``        ``// current peek And remove it``        ``prev = pq;``        ``pq.RemoveAt(0);``      ``}`` ` `      ``// if the difference``      ``// between previous element and peek is 1``      ``else``      ``{`` ` `        ``// Update the counter``        ``// These are consecutive elements``        ``c++;`` ` `        ``// Update the previous position``        ``//  with the current peek And remove it``        ``prev = pq;``        ``pq.RemoveAt(0);``      ``}`` ` `      ``// Check if current longest``      ``// subsequence is the greatest``      ``if` `(max < c)``      ``{`` ` `        ``// Store the current subsequence count as``        ``// max``        ``max = c;``      ``}``    ``}`` ` `    ``return` `max;``  ``}`` ` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr = { 1, 9, 3, 10, 4, 20, 2 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(``      ``"Length of the Longest consecutive subsequence is "``      ``+ findLongestConseqSubseq(arr, n));``  ``}``}`` ` `// This code is contributed by code_hunt.`

Output

`Length of the Longest consecutive subsequence is 4`