Skip to content
Related Articles

Related Articles

Improve Article
Longest subarray in which all elements are smaller than K
  • Difficulty Level : Hard
  • Last Updated : 22 Apr, 2021

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.

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 <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);
    }
   
    // Prlet 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)
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 



My Personal Notes
arrow_drop_up
Previous
Modify N by adding its smallest positive divisor exactly K times
Next

Construct an array of first N natural numbers such that every adjacent pair is coprime
Recommended Articles
Page :
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Delete array elements which are smaller than next or become smaller
22, Mar 18
Find the element before which all the elements are smaller than it, and after which all are greater
24, Oct 15
Longest subarray in which all elements are greater than K
12, Nov 18
Count of array elements which is smaller than both its adjacent elements
22, May 20
Size of smallest subarray to be removed to make count of array elements greater and smaller than K equal
26, Aug 20
Longest subarray in which absolute difference between any two element is not greater than X
06, May 20
Longest subarray in which all elements are a factor of K
18, Nov 20
Check if a triplet of buildings can be selected such that the third building is taller than the first building and smaller than the second building
25, May 21
Count of strings in the first array which are smaller than every string in the second array
05, Jul 19
Longest subarray not having more than K distinct elements
08, Nov 17
Longest subarray with absolute difference between elements less than or equal to K using Heaps
07, May 20
Count elements smaller than or equal to x in a sorted matrix
18, Jan 18
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
14, Sep 20
Delete all the nodes from a doubly linked list that are smaller than a given value
11, Oct 18
Print all Jumping Numbers smaller than or equal to a given value
16, Oct 15
Count of array elements which are greater than all elements on its left
15, Jul 20
Reduce the array by deleting elements which are greater than all elements to its left
16, Jun 20
Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
01, Mar 21
Maximum length of subarray such that all elements are equal in the subarray
20, Jun 20
Maximize the subarray sum after multiplying all elements of any subarray with X
24, Apr 19
Longest subarray having average greater than or equal to x
18, Aug 18
Longest Subarray with first element greater than or equal to Last element
18, Aug 18
Longest subarray having average greater than or equal to x | Set-2
10, Sep 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
patelajeet
@patelajeet
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox