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++
#include <bits/stdc++.h>
using namespace std;
int largestSubarray( int arr[], int N,
int K)
{
bool temp;
int ans = 0;
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 ;}
if (temp== true ){
ans=max(ans,count);
}
}
}
cout<<ans<<endl;
}
int main()
{
int arr[] = { 1, 8, 3, 5, 2, 2, 1, 13 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 6;
largestSubarray(arr, N, K);
return 0;
}
|
Java
import java.util.*;
public class Main {
public static int largestSubarray( int [] arr, int N,
int K)
{
boolean temp;
int ans = 0 ;
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 ;
}
if (temp == true ) {
ans = Math.max(ans, count);
}
}
}
System.out.println(ans);
return ans;
}
public static void main(String[] args)
{
int [] arr = { 1 , 8 , 3 , 5 , 2 , 2 , 1 , 13 };
int N = arr.length;
int K = 6 ;
largestSubarray(arr, N, K);
}
}
|
Python3
def largestSubarray(arr, N, K):
temp = True
ans = 0
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
if temp = = True :
ans = max (ans, count)
print (ans)
arr = [ 1 , 8 , 3 , 5 , 2 , 2 , 1 , 13 ]
N = len (arr)
K = 6
largestSubarray(arr, N, K)
|
C#
using System;
class GFG
{
static int LargestSubarray( int [] arr, int N, int K)
{
bool temp;
int ans = 0;
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 ;
}
if (temp == true )
{
ans = Math.Max(ans, count);
}
}
}
return ans;
}
static void Main()
{
int [] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };
int N = arr.Length;
int K = 6;
int result = LargestSubarray(arr, N, K);
Console.WriteLine(result);
}
}
|
Javascript
function largestSubarray(arr, N, K) {
let temp;
let ans = 0;
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 ;
}
if (temp == true ) {
ans = Math.max(ans, count);
}
}
}
console.log(ans);
}
let arr = [1, 8, 3, 5, 2, 2, 1, 13];
let N = arr.length;
let K = 6;
largestSubarray(arr, N, K);
|
Output-
5
Time Complexity: O(N2), 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++
#include <bits/stdc++.h>
using namespace std;
int largestSubarray( int arr[], int N,
int K)
{
int count = 0;
int len = 0;
for ( int i = 0; i < N; i++) {
if (arr[i] < K) {
count += 1;
}
else {
len = max(len, count);
count = 0;
}
}
if (count) {
len = max(len, count);
}
cout << len;
}
int main()
{
int arr[] = { 1, 8, 3, 5, 2, 2, 1, 13 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 6;
largestSubarray(arr, N, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void largestSubarray( int [] arr, int N,
int K)
{
int count = 0 ;
int len = 0 ;
for ( int i = 0 ; i < N; i++)
{
if (arr[i] < K)
{
count += 1 ;
}
else
{
len = Math.max(len, count);
count = 0 ;
}
}
if (count != 0 )
{
len = Math.max(len, count);
}
System.out.println(len);
}
public static void main(String[] args)
{
int [] arr = { 1 , 8 , 3 , 5 , 2 , 2 , 1 , 13 };
int N = arr.length;
int K = 6 ;
largestSubarray(arr, N, K);
}
}
|
Python3
def largestSubarray(arr, N, K):
count = 0
length = 0
for i in range (N):
if (arr[i] < K):
count + = 1
else :
length = max (length, count)
count = 0
if (count):
length = max (length, count)
print (length, end = "")
if __name__ = = "__main__" :
arr = [ 1 , 8 , 3 , 5 , 2 , 2 , 1 , 13 ]
N = len (arr)
K = 6
largestSubarray(arr, N, K)
|
C#
using System;
class GFG {
static void largestSubarray( int [] arr, int N, int K)
{
int count = 0;
int len = 0;
for ( int i = 0; i < N; i++)
{
if (arr[i] < K)
{
count += 1;
}
else
{
len = Math.Max(len, count);
count = 0;
}
}
if (count != 0)
{
len = Math.Max(len, count);
}
Console.WriteLine(len);
}
static void Main()
{
int [] arr = { 1, 8, 3, 5, 2, 2, 1, 13 };
int N = arr.Length;
int K = 6;
largestSubarray(arr, N, K);
}
}
|
Javascript
<script>
function largestSubarray(arr, N,
K)
{
let count = 0;
let len = 0;
for (let i = 0; i < N; i++)
{
if (arr[i] < K)
{
count += 1;
}
else
{
len = Math.max(len, count);
count = 0;
}
}
if (count != 0)
{
len = Math.max(len, count);
}
document.write(len);
}
let arr = [ 1, 8, 3, 5, 2, 2, 1, 13 ];
let N = arr.length;
let K = 6;
largestSubarray(arr, N, K);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Last Updated :
24 Jul, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...