Get the best out of our app
GFG App
Open App
Browser
Continue

# Length of the largest subarray with contiguous elements | Set 1

Given an array of distinct integers, find length of the longest subarray which contains numbers that can be arranged in a continuous sequence.

Examples:

```Input:  arr[] = {10, 12, 11};
Output: Length of the longest contiguous subarray is 3

Input:  arr[] = {14, 12, 11, 20};
Output: Length of the longest contiguous subarray is 2

Input:  arr[] = {1, 56, 58, 57, 90, 92, 94, 93, 91, 45};
Output: Length of the longest contiguous subarray is 5```

We strongly recommend to minimize the browser and try this yourself first.

The important thing to note in question is, it is given that all elements are distinct. If all elements are distinct, then a subarray has contiguous elements if and only if the difference between maximum and minimum elements in subarray is equal to the difference between last and first indexes of subarray. So the idea is to keep track of minimum and maximum element in every subarray.

The following is the implementation of above idea.

## C++

 `#include` `using` `namespace` `std;`   `// Utility functions to find minimum and maximum of` `// two elements` `int` `min(``int` `x, ``int` `y) { ``return` `(x < y)? x : y; }` `int` `max(``int` `x, ``int` `y) { ``return` `(x > y)? x : y; }`   `// Returns length of the longest contiguous subarray` `int` `findLength(``int` `arr[], ``int` `n)` `{` `    ``int` `max_len = 1;  ``// Initialize result` `    ``for` `(``int` `i=0; i

## Java

 `class` `LargestSubArray2 ` `{` `    ``// Utility functions to find minimum and maximum of` `    ``// two elements`   `    ``int` `min(``int` `x, ``int` `y) ` `    ``{` `        ``return` `(x < y) ? x : y;` `    ``}`   `    ``int` `max(``int` `x, ``int` `y) ` `    ``{` `        ``return` `(x > y) ? x : y;` `    ``}`   `    ``// Returns length of the longest contiguous subarray` `    ``int` `findLength(``int` `arr[], ``int` `n) ` `    ``{` `        ``int` `max_len = ``1``;  ``// Initialize result` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `        ``{` `            ``// Initialize min and max for all subarrays starting with i` `            ``int` `mn = arr[i], mx = arr[i];`   `            ``// Consider all subarrays starting with i and ending with j` `            ``for` `(``int` `j = i + ``1``; j < n; j++) ` `            ``{` `                ``// Update min and max in this subarray if needed` `                ``mn = min(mn, arr[j]);` `                ``mx = max(mx, arr[j]);`   `                ``// If current subarray has all contiguous elements` `                ``if` `((mx - mn) == j - i)` `                    ``max_len = max(max_len, mx - mn + ``1``);` `            ``}` `        ``}` `        ``return` `max_len;  ``// Return result` `    ``}`   `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``LargestSubArray2 large = ``new` `LargestSubArray2();` `        ``int` `arr[] = {``1``, ``56``, ``58``, ``57``, ``90``, ``92``, ``94``, ``93``, ``91``, ``45``};` `        ``int` `n = arr.length;` `        ``System.out.println(``"Length of the longest contiguous subarray is "` `                ``+ large.findLength(arr, n));` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 program to find length` `# of the longest subarray`   `# Utility functions to find minimum ` `# and maximum of two elements` `def` `min``(x, y):` `    ``return` `x ``if``(x < y) ``else` `y` `    `  `def` `max``(x, y):` `    ``return` `x ``if``(x > y) ``else` `y`   `# Returns length of the longest` `# contiguous subarray` `def` `findLength(arr, n):` `    `  `    ``# Initialize result` `    ``max_len ``=` `1` `    ``for` `i ``in` `range``(n ``-` `1``):` `    `  `        ``# Initialize min and max for` `        ``# all subarrays starting with i` `        ``mn ``=` `arr[i]` `        ``mx ``=` `arr[i]`   `        ``# Consider all subarrays starting` `        ``# with i and ending with j` `        ``for` `j ``in` `range``(i ``+` `1``, n):` `        `  `            ``# Update min and max in` `            ``# this subarray if needed` `            ``mn ``=` `min``(mn, arr[j])` `            ``mx ``=` `max``(mx, arr[j])`   `            ``# If current subarray has` `            ``# all contiguous elements` `            ``if` `((mx ``-` `mn) ``=``=` `j ``-` `i):` `                ``max_len ``=` `max``(max_len, mx ``-` `mn ``+` `1``)` `        `  `    ``return` `max_len`   `# Driver Code` `arr ``=` `[``1``, ``56``, ``58``, ``57``, ``90``, ``92``, ``94``, ``93``, ``91``, ``45``]` `n ``=` `len``(arr)` `print``(``"Length of the longest contiguous subarray is "``,` `                                    ``findLength(arr, n))` `                                    `  `# This code is contributed by Anant Agarwal.`

## C#

 `using` `System;`   `class` `GFG {` `    `  `    ``// Returns length of the longest ` `    ``// contiguous subarray` `    ``static` `int` `findLength(``int` `[]arr, ``int` `n) ` `    ``{` `        ``int` `max_len = 1; ``// Initialize result` `        ``for` `(``int` `i = 0; i < n - 1; i++) ` `        ``{` `            ``// Initialize min and max for all ` `            ``// subarrays starting with i` `            ``int` `mn = arr[i], mx = arr[i];`   `            ``// Consider all subarrays starting ` `            ``// with i and ending with j` `            ``for` `(``int` `j = i + 1; j < n; j++) ` `            ``{` `                ``// Update min and max in this` `                ``// subarray if needed` `                ``mn = Math.Min(mn, arr[j]);` `                ``mx = Math.Max(mx, arr[j]);`   `                ``// If current subarray has all` `                ``// contiguous elements` `                ``if` `((mx - mn) == j - i)` `                    ``max_len = Math.Max(max_len,` `                                  ``mx - mn + 1);` `            ``}` `        ``}` `        ``return` `max_len; ``// Return result` `    ``}`   `    ``public` `static` `void` `Main() ` `    ``{` `        `  `        ``int` `[]arr = {1, 56, 58, 57, 90, 92,` `                               ``94, 93, 91, 45};` `        ``int` `n = arr.Length;` `        `  `        ``Console.WriteLine(``"Length of the longest"` `                     ``+ ``" contiguous subarray is "` `                           ``+ findLength(arr, n));` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 ` ``\$b``) ` `        ``return` `\$a``;` `    ``else` `        ``return` `\$b``;` `}` `    `  `// Returns length of the longest` `// contiguous subarray` `function` `findLength(&``\$arr``, ``\$n``)` `{` `    ``\$max_len` `= 1; ``// Initialize result` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n` `- 1; ``\$i``++)` `    ``{` `        ``// Initialize min and max for all ` `        ``// subarrays starting with i` `        ``\$mn` `= ``\$arr``[``\$i``];` `        ``\$mx` `= ``\$arr``[``\$i``];`   `        ``// Consider all subarrays starting ` `        ``// with i and ending with j` `        ``for` `(``\$j` `= ``\$i` `+ 1; ``\$j` `< ``\$n``; ``\$j``++)` `        ``{` `            ``// Update min and max in this` `            ``// subarray if needed` `            ``\$mn` `= mins(``\$mn``, ``\$arr``[``\$j``]);` `            ``\$mx` `= maxi(``\$mx``, ``\$arr``[``\$j``]);`   `            ``// If current subarray has all ` `            ``// contiguous elements` `            ``if` `((``\$mx` `- ``\$mn``) == ``\$j` `- ``\$i``)` `                ``\$max_len` `= maxi(``\$max_len``,` `                                ``\$mx` `- ``\$mn` `+ 1);` `        ``}` `    ``}` `    ``return` `\$max_len``; ``// Return result` `}`   `// Driver Code` `\$arr` `= ``array``(1, 56, 58, 57, 90, ` `             ``92, 94, 93, 91, 45);` `\$n` `= sizeof(``\$arr``);` `echo` `(``"Length of the longest contiguous"` `. ` `                         ``" subarray is "``);` `echo` `(findLength(``\$arr``, ``\$n``));` `    `  `// This code is contributed ` `// by Shivi_Aggarwal.` `?>`

## Javascript

 ``

Output

`Length of the longest contiguous subarray is 5`

Time Complexity of the above solution is O(n2).

Auxiliary Space: O(1) ,since no extra space is used.

We will soon be covering solution for the problem where duplicate elements are allowed in subarray.

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials