Dado un arreglo arr[] que consta de N enteros y un entero K , la tarea es encontrar la longitud del subarreglo más largo en el que todos los elementos son más pequeños que K .
Restricciones:
0 <= arr[i] <= 10^5
Ejemplos:
Entrada: arr[] = {1, 8, 3, 5, 2, 2, 1, 13}, K = 6
Salida: 5
Explicación:
Hay un subarreglo más largo posible de longitud 5, es decir, {3, 5, 2, 2 , 1}.Entrada: arr[] = {8, 12, 15, 1, 3, 9, 2, 10}, K = 10
Salida: 4
Explicación:
El subarreglo más largo es {1, 3, 9, 2}.
Enfoque ingenuo: el enfoque más simple es generar todos los subarreglos posibles del arreglo dado e imprimir la longitud del subarreglo más largo en el que todos los elementos son menores que K .
Complejidad de Tiempo: O(N 2 )
Espacio Auxiliar: O(1)
Enfoque eficiente: para optimizar el enfoque anterior, la idea es atravesar la array y contar los elementos consecutivos de la array más pequeños que K . Imprime el conteo máximo obtenido. Siga los pasos a continuación para resolver el problema:
- Inicialice dos variables count y C para almacenar la longitud máxima del subarreglo que tiene todos los elementos menores que K y la longitud del subarreglo actual con todos los elementos menores que K , respectivamente.
- Recorra la array dada y realice los siguientes pasos:
- Si el elemento actual es menor que K , entonces incremente C .
- De lo contrario, actualice el valor de count al máximo de count y C y restablezca C a 0 .
- Después de completar los pasos anteriores, imprima el valor de conteo como resultado.
A continuación se muestra la implementación del enfoque anterior:
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>
5
Complejidad temporal: O(N)
Espacio auxiliar: O(1)
Tema relacionado: Subarrays, subsecuencias y subconjuntos en array
Publicación traducida automáticamente
Artículo escrito por patelajeet y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA