Longest subarray in which all elements are smaller than K

Given an array arr[] consisting of N integers and an integer K, the task is to find the length of the longest subarray in which all the elements are smaller than K.

Constraints:
0 <= arr[i]  <= 10^5

Examples:

Input: arr[] = {1, 8, 3, 5, 2, 2, 1, 13}, K = 6
Output: 5
Explanation:
There is one possible longest subarray of length 5 i.e. {3, 5, 2, 2, 1}.

Input: arr[] = {8, 12, 15, 1, 3, 9, 2, 10}, K = 10
Output: 4
Explanation:
The longest subarray is {1, 3, 9, 2}.

Naive Approach: The simplest approach is to generate all possible subarrays of the given array and print the length of the longest subarray in which all elements are less than K. 

Steps for implementation-

• Use a boolean variable that will contain false for any subarray when it contains any element greater than or equal to K, else true when it does not contain any such element.
• Use two more variables one for storing our answer and one for storing the length of the subarray
• Now run two nested for loops to get all subaaray
• Before finding the subarray make temp true and if got any element of the subarray greater than or equal to K then update temp as false.
• At last check for every subarray that if the temp is true then update the answer as the maximum of the answer and that subarray length.

Code-

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the length of the
// longest subarray with all elements
// smaller than K
int largestSubarray(int arr[], int N,
                    int K)
{
    //If false then all element of that subarray is not smaller than k,if true then all element of that subarray is smaller than k
    bool temp;

    // Stores maximum length of subarray
    int ans = 0;

    //stores length of subarray
    int count;

    for(int i=0;i<N;i++){
        temp=true;
        count=0;
        for(int j=i;j<N;j++){
          count++;
          if(arr[j]>=K){temp=false;}

          //Update ans variable
          if(temp==true){
              ans=max(ans,count);
          }
        }
    }

    //Print the maximum length
    cout<<ans<<endl;

}

// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 8, 3, 5, 2, 2, 1, 13 };

    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);

    // Given K
    int K = 6;

    // Function Call
    largestSubarray(arr, N, K);

    return 0;
}

Java

import java.util.*;

public class Main {
    // Function to find the length of the
    // longest subarray with all elements
    // smaller than K
    public static int largestSubarray(int[] arr, int N,
                                      int K)
    {
        // If false then all element of that subarray is not
        // smaller than k, if true then all element of that
        // subarray is smaller than k
        boolean temp;

        // Stores maximum length of subarray
        int ans = 0;

        // stores length of subarray
        int count;

        for (int i = 0; i < N; i++) {
            temp = true;
            count = 0;
            for (int j = i; j < N; j++) {
                count++;
                if (arr[j] >= K) {
                    temp = false;
                }

                // Update ans variable
                if (temp == true) {
                    ans = Math.max(ans, count);
                }
            }
        }

        // Print the maximum length
        System.out.println(ans);
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        int[] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };

        // Size of the array
        int N = arr.length;

        // Given K
        int K = 6;

        // Function Call
        largestSubarray(arr, N, K);
    }
}

Python3

def largestSubarray(arr, N, K):
    # If false then all element of that subarray is not smaller than k,
    # if true then all element of that subarray is smaller than k
    temp = True
    # Stores maximum length of subarray
    ans = 0
    # stores length of subarray
    count = 0
    for i in range(N):
        temp = True
        count = 0
        for j in range(i, N):
            count += 1
            if arr[j] >= K:
                temp = False
            # Update ans variable
            if temp == True:
                ans = max(ans, count)
    # Print the maximum length
    print(ans)


arr = [1, 8, 3, 5, 2, 2, 1, 13]
N = len(arr)
K = 6

largestSubarray(arr, N, K)

C#

// C# program for the above approach
using System;

class GFG
{
    // Function to find the length of the
    // longest subarray with all elements
    // smaller than K
    static int LargestSubarray(int[] arr, int N, int K)
    {
        // If false then all elements of that subarray are not smaller than K,
        // if true then all elements of that subarray are smaller than K
        bool temp;

        // Stores the maximum length of the subarray
        int ans = 0;

        // Stores the length of the subarray
        int count;

        for (int i = 0; i < N; i++)
        {
            temp = true;
            count = 0;

            for (int j = i; j < N; j++)
            {
                count++;
                if (arr[j] >= K)
                {
                    temp = false;
                }

                // Update ans variable
                if (temp == true)
                {
                    ans = Math.Max(ans, count);
                }
            }
        }

        return ans;
    }

    // Driver Code
    static void Main()
    {
        // Given array arr[]
        int[] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };

        // Size of the array
        int N = arr.Length;

        // Given K
        int K = 6;

        // Function Call
        int result = LargestSubarray(arr, N, K);

        // Print the maximum length
        Console.WriteLine(result);
    }
}

Javascript

// Function to find the length of the
// longest subarray with all elements
// smaller than K
function largestSubarray(arr, N, K) {
  // If false then all element of that subarray is not smaller than k,
  // if true then all element of that subarray is smaller than k
  let temp;

  // Stores maximum length of subarray
  let ans = 0;

  // stores length of subarray
  let count;

  for (let i = 0; i < N; i++) {
    temp = true;
    count = 0;
    for (let j = i; j < N; j++) {
      count++;
      if (arr[j] >= K) {
        temp = false;
      }

      // Update ans variable
      if (temp == true) {
        ans = Math.max(ans, count);
      }
    }
  }

  // Print the maximum length
  console.log(ans);
}

// Given array arr[]
let arr = [1, 8, 3, 5, 2, 2, 1, 13];

// Size of the array
let N = arr.length;

// Given K
let K = 6;

// Function Call
largestSubarray(arr, N, K);

Output-

5

Time Complexity: O(N²), because we have two nested loops to find all subarrays
Auxiliary Space: O(1), because no extra space has been used

Efficient Approach: To optimize the above approach, the idea is to traverse the array and count consecutive array elements smaller than K. Print the maximum count obtained. Follow the steps below to solve the problem:

• Initialize two variables count and C to store the maximum length of subarray having all elements less than K and length of current subarray with all elements less than K, respectively.
• Traverse the given array and perform the following steps:
  • If the current element is less than K, then increment C.
  • Otherwise, update the value of count to the maximum of count and C and reset C to 0.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach: 

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the length of the
// longest subarray with all elements
// smaller than K
int largestSubarray(int arr[], int N,
                    int K)
{
    // Stores the length of maximum
    // consecutive sequence
    int count = 0;

    // Stores maximum length of subarray
    int len = 0;

    // Iterate through the array
    for (int i = 0; i < N; i++) {

        // Check if array element
        // smaller than K
        if (arr[i] < K) {
            count += 1;
        }
        else {

            // Store the maximum
            // of length and count
            len = max(len, count);

            // Reset the counter
            count = 0;
        }
    }

    if (count) {
        len = max(len, count);
    }

    // Print the maximum length
    cout << len;
}

// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 8, 3, 5, 2, 2, 1, 13 };

    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);

    // Given K
    int K = 6;

    // Function Call
    largestSubarray(arr, N, K);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG{

// Function to find the length of the
// longest subarray with all elements
// smaller than K
static void largestSubarray(int[] arr, int N,
                            int K)
{

    // Stores the length of maximum
    // consecutive sequence
    int count = 0;

    // Stores maximum length of subarray
    int len = 0;

    // Iterate through the array
    for(int i = 0; i < N; i++)
    {

        // Check if array element
        // smaller than K
        if (arr[i] < K)
        {
            count += 1;
        }
        else
        {

            // Store the maximum
            // of length and count
            len = Math.max(len, count);

            // Reset the counter
            count = 0;
        }
    }

    if (count != 0)
    {
        len = Math.max(len, count);
    }

    // Print the maximum length
    System.out.println(len);
}

// Driver code
public static void main(String[] args)
{

    // Given array arr[]
    int[] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };

    // Size of the array
    int N = arr.length;

    // Given K
    int K = 6;

    // Function Call
    largestSubarray(arr, N, K);
}
}

// This code is contributed by chitranayal

Python3

# Python3 program for the above approach

# Function to find the length of the
# longest subarray with all elements
# smaller than K
def largestSubarray(arr, N, K):

    # Stores the length of maximum
    # consecutive sequence
    count = 0

    # Stores maximum length of subarray
    length = 0

    # Iterate through the array
    for i in range(N):

      # Check if array element
      # smaller than K
      if (arr[i] < K):
        count += 1
      else:

        # Store the maximum
        # of length and count
        length = max(length, count)

        # Reset the counter
        count = 0

    if (count):
        length = max(length, count)

    # Print the maximum length
    print(length, end = "")

# Driver Code
if __name__ == "__main__" :

    # Given array arr[]
    arr = [ 1, 8, 3, 5, 2, 2, 1, 13 ]

    # Size of the array
    N = len(arr)

    # Given K
    K = 6

    # Function Call
    largestSubarray(arr, N, K)

# This code is contributed by AnkitRai01

C#

// C# program for the above approach
using System;
class GFG {

    // Function to find the length of the
    // longest subarray with all elements
    // smaller than K
    static void largestSubarray(int[] arr, int N, int K)
    {

        // Stores the length of maximum
        // consecutive sequence
        int count = 0;

        // Stores maximum length of subarray
        int len = 0;

        // Iterate through the array
        for (int i = 0; i < N; i++)
        {

            // Check if array element
            // smaller than K
            if (arr[i] < K)
            {
                count += 1;
            }
            else
            {

                // Store the maximum
                // of length and count
                len = Math.Max(len, count);

                // Reset the counter
                count = 0;
            }
        }

        if (count != 0)
        {
            len = Math.Max(len, count);
        }

        // Print the maximum length
        Console.WriteLine(len);
    }

  // Driver code
  static void Main()
  {

        // Given array arr[]
        int[] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };

        // Size of the array
        int N = arr.Length;

        // Given K
        int K = 6;

        // Function Call
        largestSubarray(arr, N, K);
  }
}

// This code is contributed by diveshrabadiya07

Javascript

<script>
// javascript program to implement
// the above approach

// Function to find the length of the
// longest subarray with all elements
// smaller than K
function largestSubarray(arr, N,
                            K)
{

    // Stores the length of maximum
    // consecutive sequence
    let count = 0;

    // Stores maximum length of subarray
    let len = 0;

    // Iterate through the array
    for(let i = 0; i < N; i++)
    {

        // Check if array element
        // smaller than K
        if (arr[i] < K)
        {
            count += 1;
        }
        else
        {

            // Store the maximum
            // of length and count
            len = Math.max(len, count);

            // Reset the counter
            count = 0;
        }
    }

    if (count != 0)
    {
        len = Math.max(len, count);
    }

    // Print the maximum length
    document.write(len);
}

// Driver code

    // Given array arr[]
    let arr = [ 1, 8, 3, 5, 2, 2, 1, 13 ];

    // Size of the array
    let N = arr.length;

    // Given K
    let K = 6;

    // Function Call
    largestSubarray(arr, N, K);

    // This code is contributed by target_2.
</script>

Output

5

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

Related Topic: Subarrays, Subsequences, and Subsets in Array