Related Articles
Length of longest subarray with increasing contiguous elements
• Last Updated : 09 Nov, 2020

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`

Output

`3`

Time Complexity: O(N)
Auxiliary Space: 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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :