# Longest subarray in which all elements are smaller than K

• Difficulty Level : Hard
• Last Updated : 11 Jul, 2022

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

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

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 ``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);`` ` `    ``// 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

 ``

Output:

`5`

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

Related Topic: Subarrays, Subsequences, and Subsets in Array

My Personal Notes arrow_drop_up