Length of the largest subarray with contiguous elements | Set 1

23 Jun, 2022
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. 
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
C++
Java
Python3
C#
PHP
Javascript
#include<iostream>using namespace std;  // Utility functions to find minimum and maximum of// two elementsint 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 subarrayint 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}  // Driver program to test above functionint main(){    int arr[] = {1, 56, 58, 57, 90, 92, 94, 93, 91, 45};    int n = sizeof(arr)/sizeof(arr[0]);    cout << "Length of the longest contiguous subarray is "         << findLength(arr, n);    return 0;}
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 program to find length# of the longest subarray  # Utility functions to find minimum # and maximum of two elementsdef 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 subarraydef 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 Codearr = [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.
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// Utility functions to find minimum // and maximum of two elementsfunction mins($x, $y){    if($x < $y)         return $x;    else        return $y;}      function maxi($a, $b){    if($a > $b)         return $a;    else        return $b;}      // Returns length of the longest// contiguous subarrayfunction 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.?>
<script>  // Utility functions to find minimum // and maximum of two elementsfunction min( x, y) { return (x < y)? x : y; }function max( x, y) { return (x > y)? x : y; }  // Returns length of the longest // contiguous subarrayfunction findLength( arr, n){    let max_len = 1;  // Initialize result    for (let i=0; i<n-1; i++)    {        // Initialize min and max for all         // subarrays starting with i        let mn = arr[i], mx = arr[i];          // Consider all subarrays starting        // with i and ending with j        for (let 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 = Math.max(max_len, mx-mn+1);        }    }    return max_len;  // Return result}        // driver code           let arr = [1, 56, 58, 57, 90, 92, 94, 93, 91, 45];    let n = arr.length;    document.write("Length of the longest contiguous subarray is "         + findLength(arr, n));      </script>
Length of the longest contiguous subarray is 5
Time Complexity of the above solution is O(n2).
We will soon be covering solution for the problem where duplicate elements are allowed in subarray.
Length of the largest subarray with contiguous elements | Set 2 
Sam007
Shivi_Aggarwal
jana_sayantan
hardikkoriintern
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Linear Search
K'th Smallest/Largest Element in Unsorted Array | Set 1
Find Second largest element in an array
Introduction to Data Structures
Python | Using 2D arrays/lists the right way