所有元素均小于K的最长子数组

给定一个由N个整数和一个整数K组成的数组arr [] ，任务是找到所有元素均小于K的最长子数组的长度。

例子：

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}.

天真的方法：最简单的方法是生成给定数组的所有可能的子数组，并打印所有元素均小于K的最长子数组的长度。

时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：为了优化上述方法，其思想是遍历数组并计算小于K的连续数组元素。打印获得的最大计数。请按照以下步骤解决问题：

• 初始化两个变量计数和C来存储子阵列的具有所有元件的电流的子阵列中的所有元素小于K和长度小于k中的最大长度，分别。
• 遍历给定数组并执行以下步骤：
  • 如果当前元素小于K ，则增加C。
  • 否则，更新计数到最大计数值C和复位C的值设定为0。
• 完成上述步骤后，打印count的值作为结果。

下面是上述方法的实现：

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[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

输出：

5

时间复杂度： O(N)
辅助空间： O(1)