Open in App
Not now

# Length of longest subarray with increasing contiguous elements

• Last Updated : 08 Jul, 2022

Given an array arr[] of length N, the task is to find the length of the longest subarray which consists of consecutive numbers in increasing order, from the array.

Examples:

Input: arr[] = {2, 3, 4, 6, 7, 8, 9, 10}
Output: 5
Explanation: Subarray {6, 7, 8, 9, 10} is the longest subarray satisfying the given conditions. Therefore, the required output is 5.

Input: arr[] = {4, 5, 1, 2, 3, 4, 9, 10, 11, 12}
Output: 4

Naive Approach: The simplest approach to solve the problem is to traverse the array and for every index i, traverse from over-index and find the length of the longest subarray satisfying the given condition starting from i. Shift i to the index which does not satisfy the condition and check from that index. Finally, print the maximum length of such subarray obtained.

Below is the implementation of the above approach:

## C++

 // C++ implementation for the above approach #include using namespace std;   // Function to find the longest subarray // with increasing contiguous elements int maxiConsecutiveSubarray(int arr[], int N) {       // Stores the length of     // required longest subarray     int maxi = 0;       for (int i = 0; i < N - 1; i++) {           // Stores the length of length of longest         // such subarray from ith index         int cnt = 1, j;           for (j = i; j < N; j++) {               // If consecutive elements are             // increasing and differ by 1             if (arr[j + 1] == arr[j] + 1) {                 cnt++;             }               // Otherwise             else {                 break;             }         }           // Update the longest subarray         // obtained so far         maxi = max(maxi, cnt);         i = j;     }       // Return the length obtained     return maxi; }   // Driver Code int main() {     int N = 11;     int arr[] = { 1, 3, 4, 2, 3, 4,                   2, 3, 5, 6, 7 };       cout << maxiConsecutiveSubarray(arr, N);     return 0; }

## Java

 // Java implementation for the above approach import java.util.*;   class GFG{       // Function to find the longest subarray // with increasing contiguous elements public static int maxiConsecutiveSubarray(int arr[],                                           int N) {           // Stores the length of     // required longest subarray     int maxi = 0;       for(int i = 0; i < N - 1; i++)     {                   // Stores the length of length of         // longest such subarray from ith         // index         int cnt = 1, j;           for(j = i; j < N - 1; j++)         {                           // If consecutive elements are             // increasing and differ by 1             if (arr[j + 1] == arr[j] + 1)             {                 cnt++;             }               // Otherwise             else             {                 break;             }         }           // Update the longest subarray         // obtained so far         maxi = Math.max(maxi, cnt);         i = j;     }       // Return the length obtained     return maxi; }   // Driver Code public static void main(String args[]) {     int N = 11;     int arr[] = { 1, 3, 4, 2, 3, 4,                   2, 3, 5, 6, 7 };       System.out.println(maxiConsecutiveSubarray(arr, N)); } }   // This code is contributed by hemanth gadarla

## Python3

 # Python3 implementation for # the above approach   # Function to find the longest # subarray with increasing # contiguous elements def maxiConsecutiveSubarray(arr, N):         # Stores the length of     # required longest subarray     maxi = 0;       for i in range(N - 1):         # Stores the length of         # length of longest such         # subarray from ith index         cnt = 1;           for j in range(i, N - 1):               # If consecutive elements are             # increasing and differ by 1             if (arr[j + 1] == arr[j] + 1):                 cnt += 1;               # Otherwise             else:                 break;           # Update the longest subarray         # obtained so far         maxi = max(maxi, cnt);         i = j;       # Return the length obtained     return maxi;   # Driver Code if __name__ == '__main__':         N = 11;     arr = [1, 3, 4, 2, 3,            4, 2, 3, 5, 6, 7];       print(maxiConsecutiveSubarray(arr, N));   # This code is contributed by Rajput-Ji

## C#

 // C# implementation for the // above approach using System; class GFG{       // Function to find the longest // subarray with increasing // contiguous elements public static int maxiConsecutiveSubarray(int []arr,                                           int N) {      // Stores the length of   // required longest subarray   int maxi = 0;     for(int i = 0; i < N - 1; i++)   {     // Stores the length of     // length of longest such     // subarray from ith index     int cnt = 1, j;       for(j = i; j < N - 1; j++)     {       // If consecutive elements are       // increasing and differ by 1       if (arr[j + 1] == arr[j] + 1)       {         cnt++;       }         // Otherwise       else       {         break;       }     }       // Update the longest subarray     // obtained so far     maxi = Math.Max(maxi, cnt);     i = j;   }     // Return the length   // obtained   return maxi; }   // Driver Code public static void Main(String []args) {   int N = 11;   int []arr = {1, 3, 4, 2, 3, 4,                2, 3, 5, 6, 7};   Console.WriteLine(           maxiConsecutiveSubarray(arr, N)); } }   // This code is contributed by 29AjayKumar

## Javascript



Output

3

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

My Personal Notes arrow_drop_up
Related Articles